Method, system, and device for software and hardware component configuration and content generation

ABSTRACT

System, method, and circuitry for generating content for a programmable computing device based on user-selected configuration information. A settings registry is generated based on the user&#39;s selections. The settings registry and the user selected configuration information is utilized to generate the content, such as code, data, parameters, settings, etc. When the content is provided to the programmable computing device, the content initializes, configures, or controls one or more software and hardware aspects of the programmable computing device, such as boot sequence configurations, internal peripheral configurations, states of the programmable computing device, transitions between states of the programmable computing device, etc., and various combinations thereof.

BACKGROUND Technical Field

The present disclosure generally relates to electronic circuits, such asof the type often used in embedded applications. More particularly, butnot exclusively, the present disclosure relates to generating contentfor use in programming such electronic circuits, such as general purposeand application specific microcontrollers and microprocessors, includingcontent related to configuration of components of the electroniccircuits.

Description of the Related Art

Many programmable microcontroller and microprocessor architecturesutilize specific code to initialize or configure operation of themicrocontroller and microprocessor in a manner desired by the user. Thiscode can establish a clock setup, a desired boot sequence, assignexternal peripherals, configure internal peripherals, embed softwarethat is to execute on the microcontroller or microprocessor, and prepareother software or hardware configuration settings. To generate suchcode, a user would have to be trained on the specific code or hardwarenuances of the microcontroller or microprocessor, which can vary fromone architecture to another. Some architectures include a graphical toolthat enables the user to visualize the configuration settings.

BRIEF SUMMARY

Existing content generation tools are often rigid and do not provide theuser with a great deal of flexibility in generating the content.Existing content tools also are often associated with a specific device,and a different content generation tool may be required for each device.It is with respect to these and other considerations that theembodiments described herein have been made.

Embodiments described herein utilize a graphical user interface toenable a user to select and configure a programmable computing devicesuch that content (e.g., code, settings, parameters, option bits orbytes, EEPROM data, etc.) is generated for the programmable computingdevice. Embodiments described herein facilitate configurable contentbeing generated for a programmable computing device based on a user'sselections without the user having to specifically write the content. Insome embodiments, a command line interface may be employed, in additionor instead of the graphical user interface, facilitating the use ofscripting and automation as part of the configuration process.

In an embodiment, a method includes: presenting, via a graphical userinterface to a user, a list of components for a project associated witha programmable computing device; receiving, via the graphical userinterface, a first selection of at least one user-selected component forthe project from the list of components; in response to the at least oneuser-selected component being configurable: presenting, via thegraphical user interface, a first list of user-selectable templates forthe at least one user-selected component; receiving, via the graphicaluser interface, a second selection of at least one user-selectedtemplate from the first list of user-selectable templates; presenting,via the graphical user interface, a second list of user-selectableparameters for the at least one user-selected component; receiving, viathe graphical user interface, a third selection of at least oneuser-selected parameter from the second list of user-selectableparameters; generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter; and generating or updating a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generating content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:displaying, via a graphical user interface to a user, a list ofcomponents for a project associated with a programmable computingdevice; receiving, via the graphical user interface, a first selectionof at least one user-selected component for the project from the list ofcomponents; in response to the at least one user-selected componentbeing configurable: displaying, via the graphical user interface, afirst list of user-selectable templates for the at least oneuser-selected component; receiving, via the graphical user interface, asecond selection of at least one user-selected template from the firstlist of user-selectable templates; displaying, via the graphical userinterface, a second list of user-selectable parameters for the at leastone user-selected component; receiving, via the graphical userinterface, a third selection of at least one user-selected parameterfrom the second list of user-selectable parameters; generating settingsfor the at least one user-selected component based on the secondselection of the at least one user-selected template and the thirdselection of the at least one user-selected parameter; and generating orupdating a settings registry based on the settings for each of the atleast one user-selected component; and generating content for theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.

In an embodiment, a computing device comprises: a display device; amemory, which, in operation, stores computer instructions; and at leastone processor, which, in operation, executes the computer instructionsto: present, via the display device and to a user, a list of componentsfor a project associated with a programmable computing device; receive afirst selection of at least one user-selected component for the projectfrom the list of components; in response to the at least oneuser-selected component being configurable: present, via the displaydevice, a first list of user-selectable templates for the at least oneuser-selected component; receive a second selection of at least oneuser-selected template from the first list of user-selectable templates;present, via the display device, a second list of user-selectableparameters for the at least one user-selected component; receive a thirdselection of at least one user-selected parameter from the second listof user-selectable parameters; generate settings for the at least oneuser-selected component based on the second selection of the at leastone user-selected template and the third selection of the at least oneuser-selected parameter; and generate or update a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generate content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: display, via a graphical user interface to a user, a listof components for a project associated with the programmable computingdevice; receive, via the graphical user interface, a first selection ofat least one user-selected component for the project from the list ofcomponents; in response to the at least one user-selected componentbeing configurable: display, via the graphical user interface, a firstlist of user-selectable templates for the at least one user-selectedcomponent; receive, via the graphical user interface, a second selectionof at least one user-selected template from the first list ofuser-selectable templates; display, via the graphical user interface, asecond list of user-selectable parameters for the at least oneuser-selected component; receive, via the graphical user interface, athird selection of at least one user-selected parameter from the secondlist of user-selectable parameters; generate settings for the at leastone user-selected component based on the second selection of the atleast one user-selected template and the third selection of the at leastone user-selected parameter; and generate or update a settings registrybased on the settings for each of the at least one user-selectedcomponent; generate content for the programmable computing device basedon the at least one user-selected component and the settings registry;and provide the content to the programmable computing device.

In an embodiment, a method comprises: presenting, via a graphical userinterface to a user, a set of boot configuration options for a projectassociated with a programmable computing device, the presenting the setof boot configuration options including; presenting configuration pinsettings associated with the programmable computing device; presentingoption byte values associated with the programmable computing device;and presenting the set of boot configuration options; receiving, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generating or updating a settings registry based on theselected boot configuration option; and generating content for theprogrammable computing device based on the selected boot configurationoption and the settings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:presenting, via a graphical user interface to a user, a set of bootconfiguration options for a project associated with a programmablecomputing device, the presenting the set of boot configuration optionsincluding; presenting configuration pin settings associated with theprogrammable computing device; presenting option byte values associatedwith the programmable computing device; and presenting the set of bootconfiguration options; receiving, via the graphical user interface, aselection of a boot configuration option for the project selected fromthe presented set of boot configuration options; generating or updatinga settings registry based on the selected boot configuration option; andgenerating content for the programmable computing device based on theselected boot configuration option and the settings registry.

In an embodiment, a computing device comprises: a display device; amemory, which, in operation, stores computer instructions; and at leastone processor. The at least one processor, in operation, executes thecomputer instructions to: present, via a graphical user interface to auser, a set of boot configuration options for a project associated witha programmable computing device, the presenting the set of bootconfiguration options including; presenting configuration pin settingsassociated with the programmable computing device; presenting optionbyte values associated with the programmable computing device; andpresenting the set of boot configuration options; receive, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generate or update a settings registry based on the selectedboot configuration option; and generate content for the programmablecomputing device based on the selected boot configuration option and thesettings registry.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: present, via a graphical user interface to a user, a setof boot configuration options for a project associated with theprogrammable computing device, the presenting the set of bootconfiguration options including; presenting configuration pin settingsassociated with the programmable computing device; presenting optionbyte values associated with the programmable computing device; andpresenting the set of boot configuration options; receive, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generate or update a settings registry based on the selectedboot configuration option; and generate content for the programmablecomputing device based on the selected boot configuration option and thesettings registry.

In an embodiment, a method comprises: presenting, via a graphical userinterface to a user, a set of configuration options for a projectassociated with a programmable computing device, the presenting the setof configuration options including; presenting a set of internalperipherals of the programmable computing device; presenting a set ofpads of an interface of the programmable computing device; andpresenting a set of pins of the programmable computing device;receiving, via the graphical user interface, configuration selectioninformation associating an internal peripheral of the set of internalperipherals with a pin of the set of pins; maintaining a settingsregistry based on the received configuration selection information; andgenerating content for the programmable computing device based on thereceived configuration selection information and the settings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:presenting, via a graphical user interface to a user, a set ofconfiguration options for a project associated with a programmablecomputing device, the presenting the set of configuration optionsincluding; presenting a set of internal peripherals of the programmablecomputing device; presenting a set of pads of an interface of theprogrammable computing device; and presenting a set of pins of theprogrammable computing device; receiving, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintaining a settings registry based on the receivedconfiguration selection information; and generating content for theprogrammable computing device based on the received configurationselection information and the settings registry.

In an embodiment, a computing device comprises a display device, amemory, which, in operation, stores computer instructions, and at leastone processor. The at least one processor, in operation, executes thecomputer instructions to: present, via a graphical user interface to auser, a set of configuration options for a project associated with aprogrammable computing device, the presenting the set of configurationoptions including; presenting a set of internal peripherals of theprogrammable computing device; presenting a set of pads of an interfaceof the programmable computing device; and presenting a set of pins ofthe programmable computing device; receive, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintain a settings registry based on the received configurationselection information; and generate content for the programmablecomputing device based on the received configuration selectioninformation and the settings registry.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: present, via a graphical user interface to a user, a setof configuration options for a project associated with a programmablecomputing device, the presenting the set of configuration optionsincluding; presenting a set of internal peripherals of the programmablecomputing device; presenting a set of pads of an interface of theprogrammable computing device; presenting a set of pins of theprogrammable computing device; receive, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintain a settings registry based on the received configurationselection information; and generate content for the programmablecomputing device based on the received configuration selectioninformation and the settings registry.

In an embodiment, a method comprises: presenting, by a host computingdevice via a graphical user interface to a user, a list of states for aproject associated with a programmable computing device; receiving, bythe host computing device via the graphical user interface, a firstselection of a first user-selected state for the project from the listof states; receiving, by the host computing device via the graphicaluser interface, a second selection of a second user-selected state forthe project; generating, by the host computing device, a transitionbetween the first user-selected state to the second user-selected state;generating or updating, by the host computing device, a settingsregistry based on the first user-selected state, the seconduser-selected state, and the generated transitions between the firstuser-selected state and the second user-selected state; and generating,by the host computing device, content for the programmable computingdevice based on the settings registry.

In an embodiment, a system comprises: a programmable computing devicehaving a first memory, which, in operation, stores first computerinstructions; and at least one first processor. The at least one firstprocessor, in operation, executes the first computer instructions to:receive content configuring a first user-selected state, a seconduser-selected state, and transitions between the first user-selectedstate and the second user-selected state; receive a request to proceedfrom the first user-selected state to the second user-selected state;and transition the programmable computing device from the firstuser-selected state to the second user-selected state based on thetransitions. The system includes a host computing device comprising: adisplay device; a second memory, which, in operation, stores secondcomputer instructions; and at least one second processor. The at leastone second processor, in operation, executes the second computerinstructions to: present, via the display device, a list of states for aproject associated with the programmable computing device; receive afirst selection of the first user-selected state for the project fromthe list of states; receive a second selection of the seconduser-selected state for the project; generate the transitions from thefirst user-selected state to the second user-selected state; generate asettings registry based on the first user-selected state, the seconduser-selected state, and the transitions between the first user-selectedstate and the second user-selected state; and generate the content forthe programmable computing device based on the settings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:presenting, via a graphical user interface to a user, a list of statesfor a project associated with a programmable computing device;receiving, via the graphical user interface, a first selection of afirst user-selected state for the project from the list of states;receiving, via the graphical user interface, a second selection of asecond user-selected state for the project; generating a transition fromthe first user-selected state to the second user-selected state;maintain a settings registry based on the first user-selected state, thesecond user-selected state, and the generated transitions between thefirst user-selected state and the second user-selected state; andgenerating content for the programmable computing device based on thesettings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a microcontroller of a programmable computing device toperform a method. The method comprises: receiving content configuring afirst user-selected state, a second user-selected state, and transitionsbetween the first user-selected state and the second user-selectedstate; receiving a request to proceed from the first user-selected stateto the second user-selected state; and transitioning the programmablecomputing device from the first user-selected state to the seconduser-selected state based on the received content by: selecting eachexecution element associated with the second user-selected state;determining a configuration difference for each execution elementbetween the first user-selected state and the second user-selectedstate; applying at least one transition constraint for at least oneconfiguration difference for at least one execution element; andapplying the configuration differences for each execution element fromthe first user-selected state to the second user-selected state.

In an embodiment, a computing device comprises a memory, which, inoperation, stores computer instructions, and at least one processor. Theat least one processor, in operation, executes the computer instructionsto: present, via a display device, a list of states for a projectassociated with a programmable computing device; receive a firstselection of a first user-selected state for the project from the listof states; receive a second selection of a second user-selected statefor the project; generate transitions from the first user-selected stateto the second user-selected state; generate a settings registry based onthe first user-selected state, the second user-selected state, and thetransitions between the first user-selected state and the seconduser-selected state; and generate content for the programmable computingdevice based on the settings registry.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

Non-limiting and non-exhaustive embodiments are described with referenceto the following drawings, wherein like labels refer to like partsthroughout the various views, unless the context indicates otherwise.The sizes and relative positions of elements in the drawings are notnecessarily drawn to scale. For example, the shapes of various elementsare selected, enlarged, and positioned to improve drawing legibility.The particular shapes of the elements as drawn have been selected forease of recognition in the drawings. One or more embodiments aredescribed hereinafter with reference to the accompanying drawings inwhich:

FIG. 1 is a block diagram showing an example computing environment forimplementing embodiments described herein.

FIG. 2 is a block diagram showing an example conceptual structure forstoring aspects utilized in generating content in accordance withembodiments described herein.

FIG. 3 shows a logical flow diagram of a process for generating contentin accordance with embodiments described herein.

FIG. 4 shows a logical flow diagram of a process for updating agraphical user interface during the content generation process inaccordance with embodiments described herein.

FIG. 5 is an illustrative example of a component parameters file inaccordance with embodiments described herein.

FIG. 6 is an illustrative example of a component parameters file thatobtains values from the parameters file of FIG. 5 in accordance withembodiments described herein.

FIG. 7 is an illustrative example of a graphical user interface toenable a user to select components for a project in accordance withembodiments described herein.

FIG. 8 is an illustrative example of a graphical user interface toenable a user to select parameters for a user-selected component inaccordance with embodiments described herein.

FIG. 9 shows a logical flow diagram of a process for generating contentin accordance with some embodiments described herein.

FIG. 10 shows a logical flow diagram of a process for generating contentassociated with a boot sequence of a programmable computing device inaccordance with embodiments described herein.

FIG. 11 is an illustrative example of a graphical user interface toenable a user to select parameters and options associated with a bootsequence in accordance with embodiments described herein.

FIGS. 12A and 12B illustrate an example of a graphical user interface toenable a user to select signal couplings and connections associated withinternal peripherals in accordance with embodiments described herein.

FIG. 13 shows a logical flow diagram of a process for generating contentassociated with configuring internal peripherals of a programmablecomputing device in accordance with embodiments described herein.

FIG. 14 is a conceptual diagram illustrating software coherency checkingaccording with embodiments described herein.

FIG. 15 is a conceptual diagram illustrating electrical integritychecking in accordance with embodiments described herein.

FIGS. 16 to 18 are illustrative examples of a component parameters filesin accordance with embodiments described herein.

FIG. 19 is a conceptual diagram illustrating application state andsystem state transitions.

FIG. 20 shows a logical flow diagram of a process for generating contentdefining states and transitions in accordance with embodiments describedherein.

FIG. 21 shows a logical flow diagram of a process for transitioning froma first state to a second state in accordance with embodiments describedherein.

FIG. 22 shows a logical flow diagram of another process fortransitioning from a first state to a second state in accordance withembodiments described herein.

FIG. 23 is an illustrative example of a graphical user interface toenable a user to select states for a project in accordance withembodiments described herein.

FIG. 24 is a block diagram showing an example conceptual structure formanaging state information utilized in generating content in accordancewith embodiments described herein.

FIG. 25 is an illustrative example of a transition structure betweenuser-selected states in accordance with embodiments described herein.

DETAILED DESCRIPTION

In the following description, along with the accompanying drawings,certain details are set forth in order to provide a thoroughunderstanding of various embodiments of devices, systems, methods, andarticles. One of skill in the art, however, will understand that otherembodiments may be practiced without these details. In other instances,well-known structures and methods associated with, for example,circuits, such as transistors, multipliers, adders, dividers,comparators, integrated circuits, logic gates, finite state machines,accelerometers, gyroscopes, magnetic field sensors, memories, bussystems, etc., have not been shown or described in detail in somefigures to avoid unnecessarily obscuring descriptions of theembodiments. Moreover, well-known structures or components that areassociated with the environment of the present disclosure, including butnot limited to the communication systems and networks, have not beenshown or described in order to avoid unnecessarily obscuringdescriptions of the embodiments.

Unless the context indicates otherwise, throughout the specification andclaims that follow, the word “comprise” and variations thereof, such as“comprising,” and “comprises,” are to be construed in an open, inclusivesense, that is, as “including, but not limited to.”

Throughout the specification, claims, and drawings, the following termstake the meaning explicitly associated herein, unless the contextindicates otherwise. The term “herein” refers to the specification,claims, and drawings associated with the current application. Thephrases “in one embodiment,” “in another embodiment,” “in variousembodiments,” “in some embodiments,” “in other embodiments,” and othervariations thereof, refer to one or more features, structures,functions, limitations, or characteristics of the present disclosure,and are not limited to the same or different embodiments unless thecontext indicates otherwise. As used herein, the term “or” is aninclusive “or” operator, and is equivalent to the phrases “A or B, orboth” or “A or B or C, or any combination thereof,” and lists withadditional elements are similarly treated. The term “based on” is notexclusive, and allows for being based on additional features, functions,aspects, or limitations not described, unless the context indicatesotherwise. In addition, throughout the specification, the meaning of“a,” “an,” and “the” include singular and plural references.Furthermore, the particular features, structures, or characteristics maybe combined in any suitable manner in one or more embodiments to obtainfurther embodiments.

FIG. 1 is a block diagram showing an example computing environment 100for implementing embodiments described herein. Environment 100 includesa programmable computing device 108 and a host computing device 150.

The programmable computing device 108 has one or more processors 110,input/output peripherals 112 and a programmable interface 119. Asillustrated, the programmable computing device comprises one or moresystems on a chip (SoC) 109, each of which may include one or moreprocessors 110, one or more input/output peripherals 112, and aprogrammable interface 119, which may couple to the input/outputperipherals 112 and the programmable interface 119 of the programmablecomputing device 108.

The processors 110 may have one or more processing cores 114, one ormore memories 116, and associated configuration pins, jumpers orswitches 118. The associated configuration pins, jumpers or switches 118may typically be at the level of the SoC 109 instead of at the processorlevel. In FIG. 1 , processor 110 a includes processing cores 114 a to114 n, and processor 110 b includes processing core 114 x. The computingdevice 108 may include other internal peripherals 132, such as graphicsprocessing units, wireless network modules, analog-to-digitalconverters, microelectromechanical systems, sensors, etc., and othergeneral purpose input/output (GPIO) interfaces 134. The internalperipherals 132 and GPIOs 134 may be at various levels, such as aprocessor 110 level, a SoC 109 level, a programmable computing devicelevel 108, a processing core 114 level (e.g., configurable components ofthe processing core 114, not shown in FIG. 1 for ease of illustration),or combinations thereof.

The programmable computing device 108 may be a microprocessor,microcontroller, system board or other computer device that is orcontains one or more integrated circuits having a programmable interface119. In some embodiments, the programmable computing device 108 maycomprise a plurality of SoCs (see SoC 109) each having a programmableinterface 119, and the programmable computing device 108 may comprise acommon programmable interface 119, which, in operation, may couple tothe programmable interfaces 119 of each of the plurality of SoCs.

In some embodiments, the processors 110 may include a state machine, amicroprocessor, a programmable logic circuit, discrete circuitry, logicgates, registers, etc., and various combinations thereof. In operation,the processors 110 may control booting of the programmable computingdevice 108, overall operation of the programmable computing device 108,execution of applications programs by the programmable computing device108, communications between internal peripherals 132 and externaldevices, such as the illustrated external peripherals 170, etc.

The programmable computing device 108 also includes one or more memories116 such as one or more volatile or non-volatile memories, such as flashmemories, or a combination thereof, which may store, for example, all orpart of instructions and data related to applications and operationsperformed by the programmable computing device 108. For example, one ormore of the memories 116 may store computer instructions that whenexecuted by the processor 110, boot the programmable computing device108 or cause the programmable computing device 108 to perform a desiredfunction. The memories 116 may also store information that is used toconfigure the hardware of the programmable computing device 108. Forexample, the option bytes 117 shown in FIG. 1 , may store informationthat is used to configure the hardware of the programmable computingdevice 108. The memories 116 may be included at various levels, such asthe programmable computing device 108 or board level, or board level, atthe SoC 109 level, at a processor level 110, at a processing core 114level, etc., and various combinations thereof.

As mentioned above, the programmable computing device 108 also includesone or more internal peripherals 132, such as a universal asynchronousreceiver-transmitter (UART), a timer, an analog-to-digital (A/D)converter, a digital to analog (D/A) converter, an inter integratedcircuit (IC2) interface, a serial peripheral (SPI) interface, etc. Asillustrated, processor 110 a includes one or more internal peripherals132 separate from processing cores 114 a-114 n, processor 110 b includesone or more internal peripherals 132 separate from processing core 114x, and SoC 109 includes one or more internal peripherals 132 separatefrom processors 110 a, 110 b. Internal peripherals 132 may also beincluded at the programmable computing device 108 or board level, andprocessing cores may have configurable components as well.

The input/output peripherals 112 may include one or more general purposeinput/output (GPIO) interfaces 134, dedicated input or output interfaces(e.g., serial input/output ports), wireless interfaces, etc. In someembodiments, the input/output peripherals 112 may be configured toreceive input data from other computing devices or may be configured toprovide output data to other computing devices, such as the externalperipherals 170. For example, a GPIO 134 may be configured to receivedata from an external computing device and provide the data to aninternal peripheral 132, to receive data from an internal peripheral 132and provide the data to an external computing device, or combinationsthereof. As illustrated, processing core 114 a includes one or more GPIOinterfaces 134, processor 110 a includes one or more GPIO interfaces 134separate from processing cores 114 a-114 n, processor 110 b includes oneor more GPIO interfaces 134 separate from processing core 114 x, andprogrammable device 108 includes one or more GPIO interfaces 134separate from processors 110 a, 110 b. GPIO interfaces 134 may beincluded at various levels, such as the programmable device 108 level,the SoC 119 level, etc., and various combinations thereof.

The programmable computing device 108 may also include one or more bussystems (not illustrated) at various levels, which may be configuredsuch that the SoCs 109, processors 110, input/output peripherals 112(e.g., at the boundary between a board and an SoC), processing cores114, memories 116, configuration pins 118 (e.g., at the boundary betweena board and an SoC), internal peripherals 132, GPIOs 134, or othercircuits or circuitry (not illustrated) may be communicatively coupledto one another to send or receive, or send and receive, data to or fromother components. The bus system may include one or more of data,address, power, or control busses, or some combination thereof,electrically coupled to the various components of the programmablecomputing device 108.

The host computing device 150 includes a processor 152, an input/outputinterface 154, a memory 156 and a display 158. The host computing device150 is configured to employ embodiments described herein to generate agraphical user interface to present to a user, to enable the user toselect and configure components, and to generate content from thosecomponents for programming and configuring the software or hardware, orboth, of the programmable computing device 108. Processor 152 mayinclude one or more processing cores that are configured to executecomputer instructions to employ embodiments described herein. While thehost computing device 150 may be implemented as a standalone system,embodiments are not so limited. For example, distributed embodiments maybe employed (e.g., an application executing on a local host computingdevice may communicate with a remote server, which may provide all orpart of the functionality of the host computing device 150).

Memory 156 may include one or more various types of non-volatile and/orvolatile storage technologies. Examples of memory 156 may include, butare not limited to, flash memory, hard disk drives, optical drives,solid-state drives, various types of random-access memory (RAM), varioustypes of read-only memory (ROM), other computer-readable storage media(also referred to as processor-readable storage media), or the like, orany combination thereof. Memory 156 may be utilized to storeinformation, including computer-readable instructions that are utilizedby processor 152 to perform actions, including embodiments describedherein. Memory 152 may also store other information, which is discussedin more detail below in conjunction with FIG. 2 .

Input/output interface 154 may include one or more other data input oroutput interfaces. For example, the input/output interface 154 mayinclude or provide data to a display device 158, which can be used topresent the graphical user interface to the user. The input/outputinterface 154 can accept input from the user to select and configure orcustomize components, as described herein. Moreover, the input/outputinterface 154 is configured to provide content generated as describedherein to the programmable computing device 108.

Embodiments of the system 100 of FIG. 1 may include fewer componentsthan illustrated, may include more components than illustrated, and maycombine or separate components in various manners. For example, theprogrammable interface 119 of the programmable computing device 108 maybe part of the input/output peripherals 112, multiple programmableinterfaces may be employed (e.g., for different SoCs 109, processors110, or processing cores 114), the processing cores 114 a to 114 n ofprocessor 110 a may have separate memories 116 and configuration pins118, shared memories 116 and configuration pins 118, input peripherals132, input/output peripherals 112, and GPIO interfaces 134 may becombined or split in various embodiments, or various combinationsthereof. In another example, the display 158 may be part of theinput/output interface 154 in some embodiments (e.g., a touchscreen maybe employed display options and to receive user input).

FIG. 2 is a block diagram showing an example conceptual structure of amemory 156 for storing aspects utilized in generating content inaccordance with embodiments described herein. The memory 156 may be thememory 156 of the host computing device 150 from FIG. 1 .

The memory 156 may store configurable components 204, ready-to-gocomponents 220, a global map or settings registry 222, and settingsstructures for each configurable component 224. In some embodiments, theglobal map or settings registry 222 and the settings files may becombined. Memory 156 may also store computer instructions 226 that areexecutable by a processor (e.g., processor 152 in FIG. 1 ) to performembodiments described herein. The data stored in the memory 156 mayutilize standard syntax, e.g., JSON schema, which can enable the use ofstandard libraries using or taking benefit from that syntax, e.g., JSONforms.

Configurable components 204 include at least one configurable component206 a-206 c. The configurable components 206 a-206 c include or describesome configuration, control, implementation, or functionality associatedwith software or hardware aspects of a programmable computing device,such as programmable computing device 108 in FIG. 1 . These configurablecomponents 206 a-206 c have one or more parameters (e.g., constraints orvariables) that can be selected, or set by the user.

Configurable components 206 a-206 c may include parameters files,template files, or both. For example, configurable component 206 aincludes parameters 208 and templates 210, configurable component 206 bincludes parameters 209 but no templates, and configurable component 206c includes templates 211 but no parameters.

Parameters 208 and 209 may include one or more files that storeparameters of the configurable component that can be selected or set bythe user. The parameters 208 and 209 may store the possible values theuser can select for one or more parameters. These values can be directvalues, advanced expressions, queries to the global map or settingsregistry, or queries to other parameters (e.g., other parameters 208,209) or to databases (not illustrated). The parameters 208 and 209 maybe used to configure or implement one or more software or hardwareaspects associated with the programmable computing device. In variousembodiments, one or more generic or customized grammar structures may beutilized to write or generate the parameters 208 and 209. This grammaris a set of rules indicating how to express the configurability of acomponent or template.

In various embodiments, one or more parameters of the parameters 208 and209 may be at least partially defined or limited by another parameter,component, or template. Accordingly, one or more parameters can bedependent on one or more other parameters, components, or templates,which can create various dependencies among parameters.

Templates 210 and 211 may include one or more files that storepreviously generated templates. The templates 210 and 211 areconfiguration tools for the programmable computing device. The templates210 and 211 may be files that contain instrumented content that is usedto generate content to initialize, configure, or control a software orhardware aspect of the programmable computing device 108. In someembodiments, the templates 210 and 211 contain C code instrumented withhandlebars templating language. At a content generation stage, theinstrumented parts may be replaced by information coming from the globalmap or settings registry 222, which is described in more detail below.

In some embodiments, one or more of the templates 210 and 211 may relydirectly or indirectly on parameters selected by the user, for example,through the global map or settings registry. For example, configurablecomponent 206 a may include a single template 210, which uses globalregistry values corresponding to four user-selectable parameters, whichare defined in the parameters 208. In some embodiments, the templatesmay be selected or linked to one another by the user, or a user mightchoose whether a particular template is used during the contentgenerating process, including choosing between mutually exclusivetemplates. In at least one embodiment, one or more templates 210 and 211may rely or obtain values from other templates, other components, orother software or hardware projects that are to be implemented on theprogrammable computing device.

The ready-to-go components 220 are previously designed components thatconfigure or pilot one or more software or hardware aspects of theprogrammable computing device. In at least one embodiment, theready-to-go components 220 may also be referred to as non-configurablecomponents. In various embodiments, the ready-to-go components 220 donot include any user-selectable features. Rather, the ready-to-gocomponents 220 are fully operational and can configure or implement oneor more software or hardware aspects of the programmable computingdevice without further input or selections by the user. As discussed inmore detail below, the user may be presented with a graphical userinterface in which the user can select to add or remove ready-to-gocomponents from the project.

The settings for a configurable component 224 are optional and store theresults of the configuration choices for each of the user-selectedconfigurable components, parameters, and templates. For example, thespecific settings for a configurable component 224 may identify one ormore templates from the templates 210 that were selected by the user.The settings for a configurable component 224 may also contain thevalues associated to the parameters 208 that were selected by the user.In some embodiments, the settings for a configurable component 224 mayalso store optional user settings for software or hardware aspects ofthe programmable computing device. In some embodiments, the settings fora configurable component 224 may be employed for debugging purposes.

In some embodiments, a single settings structure 224 is generated foreach selected configurable component 204. In other embodiments, multiplesettings structures 224 are generated for a single selected configurablecomponent 204. In yet other embodiments, a single settings structure 224may be generated for multiple selected configuration components 204.Moreover, multiple settings structures 224 can be generated for multipleselected configuration components 204. In some embodiments, thesesettings structures 224 may be stored as JSON files.

The global map or settings registry 222 is an in-memory objectcentralizing all the user selections and settings that are generated viathe user's selection of configurable components 204, parameters, andtemplates. The global map or settings registry in-memory object also maybe stored and synchronized with a file to facilitate its persistence. Byextension, the global map or settings registry 222 also may refer to asoftware component providing a dictionary, getters/setters, or servicesto compute or re-compute content for a programmable computing devicebased on expressions or dependencies. Overall, the global map orsettings registry 222 is a dictionary or database memorizing softwarecomponents settings and hardware platform settings of the programmablecomputing device. In some embodiments, separate global maps or settingsregistries may be generated for various software and hardware aspects ofthe programmable computing device.

As described herein, the global map or settings registry 222 is asoftware component implementing a set of services to retrieve, store,compute, re-compute, or resolve values selected by the user. In variousembodiments, the global map or settings registry 222 may comprise a JSONobject with a set of accessors (API) to the components, templates, andparameter values selected by the user. In some embodiments, the globalmap or settings registry 222 may be a concatenation of all the settingsfor each configurable component 224. In other embodiments, the globalmap or settings registry 222 may be updated directly from the user'sselections without using or accessing the settings for each configurablecomponent 224. In some embodiments, the global map or settings registry222 includes or is associated with services in addition to the JSONobjects.

As discussed in more detail below, the host computing device, such ashost computing device 150 in FIG. 1 , utilizes the global map orsettings registry 222, along with the selected configurable components204 and any selected ready-to-go components 220, to generate contentthat is provided to and used by the programmable computing device toimplement, control, or configure one or more software aspects of theprogrammable computing device, one or more hardware aspects of theprogrammable computing device, or both.

The operation of one or more embodiments will now be described withrespect to FIGS. 3 and 4 , and for convenience will be described withrespect to the embodiments of FIGS. 1 and 2 described above. In at leastone of various embodiments, processes 300 and 400 described inconjunction with FIGS. 3 and 4 , respectively, may be implemented by orexecuted on one or more computing devices, such as host computing device150 in FIG. 1 executing instructions, such as instructions 226 (see FIG.2 ) stored in the memory 156.

FIG. 3 shows a logical flow diagram of a process 300 for generatingcontent in accordance with embodiments described herein. Process 300begins, after a start block, at block 302, where a project is initiatedfor generating content to implement on or configure a programmablecomputing device, such as programmable computing device 108 in FIG. 1 .In some embodiments, the project initiation includes presenting agraphical user interface to a user. The graphical user interfacerequests or includes an input interface for the user to select aparticular programmable computing device. A global map or settingsregistry for the project is also initiated. The global map or settingsregistry may include a defined structure, which may be predefined, orinitial settings for the particular programmable computing device.

In some embodiments, a single project for software and hardware isinitiated for the programmable computing device. As such, a singleglobal map or settings registry may be generated. In some embodiments, afirst project may be initiated for software of the programmablecomputing device and a second project may be initiated for hardware ofthe programmable computing device. Separate global maps or settingsregistries may then be generated for the separate projects, and thoseregistries may have dependencies on each other. In at least one suchembodiment, process 300 may be executed sequentially or in parallel forthe separate software and hardware projects. In some embodiments,process 300 may be executed for concurrent processing of both thesoftware and hardware projects.

Process 300 proceeds to block 304, where a list of a plurality ofcomponents for the project are presented to the user in the graphicaluser interface. In at least one embodiment, the list of components maybe generated for the user based on the particular programmable computingdevice selected for the project. These components may be thosecomponents that are designed for or compatible with the programmablecomputing device. In some embodiments, the list of components may beselected for presentation based on the execution context specificitiesof the programmable computing device. In some architectures, anexecution context for a particular processing core or a particular modeof operation (e.g. TrustZone mode) may be selected by the user. The listof components presented to the user can be dependent on these userselections. The list of components may include configurable components,such as configurable components 204 in FIG. 2 ; or non-configurablecomponents, such as ready-to-go components 220 in FIG. 2 ; or somecombination thereof.

Process 300 continues at block 306, where a user selection of acomponent is received. In at least one embodiment, a user may select acomponent from the list via the graphical user interface. Althoughprocess 300 discusses a user's selection of a single component at atime, embodiments are not so limited. In some embodiments, a pluralityof components may be selected by a user.

Process 300 proceeds next to decision block 308, where a determinationis made whether the selected component is a configurable component or anon-configurable component. In some embodiments, the components may havea tag or other identifier indicating whether the component isconfigurable by the user or not. In other embodiments, a database orother data structure of configurable and non-configurable components maybe maintained and compared against the selected component. If theselected component is configurable, then process 300 flows from block308 to block 310; otherwise, process 300 flows from block 308 to block322.

As mentioned above, a plurality of components may be selected by a user;if so, process 300 flows from block 308 to block 310 for any selectedconfigurable components and from block 308 to block 322 for any selectednon-configurable components. In various embodiments, the user may beenabled to configure each selected component individually or in parallelvia the graphical user interface.

At block 310, a list of one or more user-selectable templates for theuser-selected configurable component is presented to the user via thegraphical user interface. In some embodiments, the list ofuser-selectable templates may include one or more characteristics of thetemplate that may be set or selected by the user, such as if thetemplate links to another template, component, or project.

The list of user-selectable templates can be customized or defined toutilize user-desired user interface elements. Accordingly, the userinterface can be customized for the different user-selectable templatessuch that the user can select, define, or set one or morecharacteristics of the templates. In some embodiments, thiscustomization can allow the templates to use data from databases insteadof listing all possible values. In some embodiments, this customizationcan specify the user-selectable aspects of the templates. In someembodiments, a user may select between mutually-exclusive templates,with only one of the templates being selected to use in the contentgeneration process for the user-selected configurable component.

In various embodiments, block 310 may be optional and may not beperformed. For example, in some embodiments, a template may be appliedby default without a user's selection. In some embodiments, a templatemay not be employed in the configuration of a configurable component.

Process 300 proceeds from block 310 to block 312, where user-selectedtemplates are received for the configurable component. In someembodiments, the user-selected template may include other informationprovided by the user defining how the template is to be used.

In some embodiments, one or more configurable component may includeuser-selectable parameters, but not include user-selectable templates.In such an embodiment, blocks 310 and 312 may not be performed for thoseselected configurable components that do not include user-selectabletemplates.

Process 300 continues from block 312 to block 314, where a list of oneor more user-selectable parameters for the user-selected configurablecomponent is presented to the user via the graphical user interface. Insome embodiments, the list of user-selectable parameters may include alist of the parameters and the possible values for those parameters. Inother embodiments, the list may identify the parameters and include aninterface to receive a user-defined value. In other embodiments, thelist may identify the parameters and include an interface to receive auser-defined value limited to some boundaries. In some embodiments, thelist of user-selectable parameters may include a list of the parametersand the possible values for some of those parameters, and include aninterface to receive a user-defined value for other parameters, with orwithout boundaries.

The list of user-selectable parameters can be customized or defined toutilize user-desired user interface elements. Accordingly, the userinterface can be customized for the different user-selectable parameterssuch that the user can select, define, or set one or more parameters. Insome embodiments, this customization can allow the parameter selectionsto be driven by data from databases, expressions, formulas, ordependencies from other parameters, instead of listing all possiblevalues. In other embodiments, this customization can specify theuser-selectable aspects of the parameters. In some embodiments, thiscustomization can specify the boundaries applicable to the user-definedvalues of the parameters. In various embodiments, the list of parametersmay be a default list for its corresponding component.

In some embodiments, this list of user-selectable parameters may alsoinclude other information that can help the user understand theramifications of selecting specific parameters. For example, thegraphical user interface can include links to reference manuals,diagrams, tool tips, etc. that help explain the parameters and howdifferent user selections can impact other components or parameters.

Process 300 proceeds from block 314 to block 316, where user-selectedparameters are received for the configurable component. In at least oneembodiment, a value of one or more parameters is received from the user.As mentioned above, the user may select the particular value from thelist of possible values for the parameter via the graphical userinterface. Alternatively, the user may input the specific value of theparameter, according to boundaries if they are specified. Non-acceptablevalues of user input may trigger user warnings or automatic adjustments(e.g., rounding down to a maximum value, etc.).

In some embodiments, the configurable component may includeuser-selectable templates, but not include user-selectable parameters.In such an embodiment, blocks 314 and 316 may not be performed for thoseselected configurable components that do not include user-selectableparameters.

Process 300 continues from block 316 to block 318, where one or moresettings structures are generated for the selected configurablecomponent based on the user-selected parameters, user-selectedtemplates, or some combination thereof. In some embodiments, thesettings structures may be a list or other data structure identifyingthe parameters selected by the user and the associated values selectedby the user, the templates selected by the user and any customizablefeatures of the selected templates, or other information indicating howthe configurable component was customized by the user.

In various embodiments, the settings structures may be updated byoverlaying the user-selected information for the user-selected componentto override some values of that component. In some embodiments, acomponent can override a parameter from another component, such as whencomponents rely on one another for computation. In other embodiments, acomponent can override a query from another component, such as bychanging the choices the user can make associated with that component.Because some parameters can be set or defined by other templates orcomponents, some parameter values may be propagated or overlaid based onthe dependencies between parameters, templates, and components. Forexample, application-level values may override driver-level values. Inthis way, user selections and changes at the application level canchange values or parameters at the driver level, which may then bereflected in the global map or system registry. As mentioned above, insome embodiments the settings structure 224 and the global map orsettings registry 222 may be combined. Thus, in some embodiments block318 may be combined with the next block 320.

Process 300 proceeds from block 318 to block 320, where the global mapor settings registry 222 is updated based on the settings for eachconfigurable component. As mentioned above, the global map or settingsregistry is an in-memory object centralizing all the user selections andsettings that are generated via the user's selection of configurablecomponents 204, parameters, and templates. Accordingly, the parameters,templates, values, and other information selected by the user for theuser-selected configurable component are added, updated, or otherwiseincluded in the global map or settings registry for the project based onthe settings files. The global map or settings registry may be arrangedsuch that the user-selected values are literals that can be writtendirectly in the hardware unit registers by the driver software of theprogrammable computing device. In various embodiments, the global map orsettings registry may also retain whatever is used to update the resultof the expressions, formulas, or dependencies based on the user'sselections. In this way, when a value is updated, such as changed by auser via the graphical user interface, all related values are updatedaccordingly in the global map or settings registry.

Although FIG. 3 shows the global map or settings registry being updatedbased on the settings structures being generated from the user'sselections, embodiments are not so limited. In some embodiments, theglobal map or settings registry may be updated in real time as the userselects components, parameters, or templates. Accordingly, in someembodiments, the use of settings structures may be optional. In someembodiments, an image of the user selection may be maintained in theJSON files.

After block 320, or if, at decision block 308, the selected component isnot configurable, then process 300 flows to block 322. At block 322,content for the programmable computing device is generated based on theselected component and the information stored in the global map orsettings registry 222. It is noted that information stored in the globalregistry and related to other components may be used to generatecontent. For example, information related to a DMA associated with theselected component (e.g., a template associated with the DMA) may beemployed to generate content associated with the selected component.

The global map or settings registry 222 may operate as a consolidateddatabase of values that can be used to generate the content from theuser-selected templates and user-selected components. This content maybe, for example, plain code (e.g., C code) that is used by theprogrammable computing device to initialize, configure, or control asoftware or hardware aspect of the programmable computing device 108.Accordingly, the generated content may be initialization code,application code, configuration code, a device tree blob (a hardwaredescription interpreted at runtime), etc. The content may also be othersettings, parameters, or other information that initializes, configures,or controls a software or hardware aspect of the programmable computingdevice. The content may also comprise associated documentation.

In various embodiments, overlays, handlebars, or a similar templating orreplacement engine may be used to resolve dependencies or expressions(e.g., handlebars expressions) in the user-selected templates or in theconfigurable components by accessing the values stored in the global mapor settings registry. In other embodiments the latter accessed valuesare stored in one or more settings files containing the same informationas the settings registry in-memory object. The result of this step mayproduce actual code that can be compiled by a compiler for use in theprogrammable computing device. In various embodiments, this codegeneration does not modify the source code of the selected components.Thus, the components can be reused in their original form for the sameproject or other projects without having to modify the components. Insome embodiments, the system may also generate code not requiringcompilation, but which can be interpreted by virtual machines (e.g.,micro-python, JavaScript). In other embodiments, the system may generatedata structures which are used during runtime to adapt the behavior ofthe programmable computing device.

As described herein, the graphical user interface allows the user toselect components and values. In other embodiments, this can beperformed without a graphical user-interface, through a command lineinterface.

In some embodiments, the graphical user interface may also present acontent preview to the user based on the currently selected parameters.In this way, the content generation can be triggered each time aparameter is set. When all components are configured, the content may befinally generated for the programmable computing device because allvalues are available with the desired values (overlays applied,expressions/formulas/dependencies computed).

Process 300 proceeds from block 322 to decision block 324, where adetermination is made whether the user is to select another component.If another component is selected, process 300 loops from block 324 toblock 306 to receive the user selection of the other component;otherwise, process 300 flows from block 324 to block 326. As mentionedabove, process 300 may also be performed with the user selectingmultiple components, which can then be configured by the user togetheror individually.

At block 326, the content generated for each user-selected component isbuilt into a binary image for the project. This binary image is theinformation usable by the programmable computing device to initialize,configure, or control its hardware, software, or a combination thereof.In some embodiments, all generated content is utilized to build thebinary image for the project. In other embodiments, a portion, but notall of the generated content, is utilized to build the binary image forthe project. For example, in the case of interpreted languages, onlyspecific content (e.g., generated code) may be uploaded in a specificmemory region of the programmable computing device without regeneratingthe binary interpreting it.

It is noted that various code generation services can be invoked togenerate content for user-selected components, and combinations of codegeneration services may be employed to generate content for a singleuser-selected components. For example, content may be generated by adefault C code generation service, by a device tree code generationservice coming from a community, by a proprietary 3rd party codegeneration service, by a code generation service generating Python codeor any other language, etc., and various combinations thereof.

As illustrated, process 300 proceeds from block 326 to block 328, wherethe binary image is provided to the programmable computing device. Insome embodiments, process 300 may sometimes return to block 304 fromblock 326, using the content generated at 326 as an intermediate inputto the process. In some embodiments, process 300 may be executedmultiple times to generate different content for differentconfigurations of the programmable computing device. In this way,different configurations can be provided to separate programmablecomputing devices (even if a same type of programmable computingdevice), or different configurations can be provided to a singleprogrammable computing device to allow a user of the programmablecomputing device to change between the different configurations.

After block 328, process 300 terminates or otherwise returns to acalling process to perform other actions.

FIG. 4 shows a logical flow diagram of a process 400 for updating agraphical user interface during the content generation process inaccordance with embodiments described herein.

Process 400 begins, after a start block, at block 402, where a userinterface of a project is presented to a user. The project may be asoftware project, a hardware project, or various combinations thereof.In various embodiments, this user interface is the graphical userinterface displayed to the user described above with reference to FIG. 3. This user interface may display components that are selectable for usewith a programmable computing device, parameters selectable by a userfor a particular configurable component, templates selectable by theuser for a particular configurable component, and other information.Moreover, the user interface may display the values of variousparameters, settings, templates, and components, whether selected by auser, linked from one template to another, dependent on other values, ordefined by a template or component, which may be predefined.

Process 400 proceeds from block 402 to block 404, where a change in aglobal map or settings registry value is received. As described above,the global map or settings registry is updated in response to auser-selected configurable component, a user-selected parameter value, auser-selected template, etc. These user-selectable conditions mayindicate a change in a global map or settings registry value.

Process 400 continues from block 404 to block 406, where the change ispropagated through the global map or settings registry. Becauseparameters, templates, and components can rely or depend on values ofother parameters, templates, components, or projects, a change in onevalue can result in a change in another. Thus, the received change inthe global map or settings registry value is propagated through theglobal map or settings registry in accordance with these dependencies.

Process 400 proceeds next from block 406 to block 408, where the userinterface is updated based on the propagated changes in the global mapor settings registry. The user-interface also may be updated based ongenerated content. In some embodiments, the user interface queries theglobal map or settings registry, and any changes that occurred whileupdating the global map or settings registry are obtained and displayedin the user interface.

Process 400 continues next at decision block 410, where a determinationis made whether the project is associated with another project. If so,process 400 flows to block 412, where the change is propagated throughthe global map or settings registry of the other project. Process 400loops to block 404 to receive another change to a global map or settingsregistry value from a user.

Embodiments of the process 300 illustrated in FIG. 3 and of the process400 illustrated in FIG. 4 may have more process blocks than illustrated,may have fewer process blocks than illustrated, and the process flow maybe modified in various ways. For example, process 300 may be modified toinclude a block presenting configuration update information to the userbased on the updated global map or settings registry at 320 (e.g.,calling the process 400).

FIG. 5 is an illustrative example of a component parameters file inaccordance with embodiments described herein. In this example, thecomponent parameters identify various different characteristics of theparameters that are selectable by a user along with the possible values.For example, the parameter “DCH1” specifies the duty cycle for a channel1 timer that is selectable by a user. In this example, the label, suchas for display to the user in the graphical user interface is“DutyCycleCH1.” The type of the parameter is a number. Thus, the valueselected by the user is a number. The minimum value that the user canselect is zero and the maximum value the user can select is 100.Finally, the parameter indicates that the unit for this parameter is apercentage.

FIG. 6 is an illustrative example of a parameters file for anapplication level component that obtains or reuses parameter values fromthe component parameters file of FIG. 5 in accordance with embodimentsdescribed herein. The values of a timer HAL driver are overlaid withvalues computed from application level parameters (e.g., computing atimer period from an application frequency). In this example, thetemplate establishes an LED dimmer whose characteristics are obtainedfrom the parameters shown in FIG. 5 . For example, the “source” of thecharacteristics are obtained from “Parameters from FIG. 5 .json,” whichis an illustrative example of depending on the parameter values in FIG.5 . The template defines the channel 1 timer as “CH1.” The pulse of thistimer is set as“(selfresources.pwm_led_dimmer.blocks.configs.%current_config%.fields.DCH1*%this%.Period)/100.”As noted, this definition relies on “DCH1,” which is the channel 1 timerdefined in the parameters. The “this” is the current “object” or currentlevel in the JSON object. In this particular example, “this” is the“fields” stage and “this.% Period %” refers to the Period field of thecurrent object level.

FIGS. 5 and 6 are for illustrative purposes and should not be consideredas limiting. Other information, data structures, and overlay orhandlebar technology may be used to establish the content for theprogrammable computing device from the components, templates, andparameters selected by the user in accordance with embodiments describedherein.

FIG. 7 is an illustrative example of a graphical user interface 700 toenable a user to select components for a project in accordance withembodiments described herein. In this illustrative example, thegraphical user interface 700 may display a “Sample Connection”collection of components: “Middleware USB,” “Middleware BT,” and “DriverWi-Fi.” In this example, Sample connection is an applicative codecomponent having three dependencies: two middlewares components and onedriver component. For this example situation, these components arerequired to have a complete project. In this example, the user canselect which of these components to open other components for theselection. For example, the user can select the “Middleware BT,” whichallows the user to then select “Driver BT” or “Driver Common.” This typeof user interface can enable a user to progress through variousdifferent layers of components to select the appropriate components fortheir project. Moreover, this graphical user interface tool can help theend-user in resolving the dependencies by proposing appropriatecomponents or by automatically selecting the component when appropriate(e.g., when only one component is filling the criteria).

FIG. 8 is an illustrative example of a graphical user interface 800 toenable a user to select parameters for a user-selected component inaccordance with embodiments described herein. This graphical userinterface 800 can display different configurations and possible valuesfor multiple parameters, depending on which configurable components areselected by the user.

FIGS. 7 and 8 are for illustrative purposes and should not be consideredas limiting. Other information or data may be displayed to a user viathe graphical user interfaces in accordance with embodiments describedherein.

With reference to FIGS. 1 and 2 , the programmable computing device 108may comprise a microcontroller (MCU) or microprocessor (MPU), which mayinclude one or more SoCs. The SoCs may include one or processors, andthe processors may have one or more processing cores. See processors 110a, 110 b, and processing cores 114 a to 114 n and 114 x of FIG. 1 . Theprocessing cores of a processor may comprise, for example, a CPU, afloating-point unit, etc. The processing cores need to be configured,including configuring the process of starting up the programmablecomputing device 108, which may be referred to as the programmablecomputing device's 108 boot sequence.

In configuring a boot process of a SoC, there are several factors thatmay need to be considered. A SoC may have several processors, and eachprocessor may have several cores, such as described above with referenceto FIG. 1 . The cores may employ virtualization, such astrusted/non-trusted worlds in ARM TrustZone technology. The SoC may beorganized into trusted and non-trusted worlds (e.g., in an executioncontext a processor core in trusted world may be able to utilizeresources in the trusted world of which it is a member, while thoseresources would not be available to processing cores outside the trustedworld). A hardware execution unit or circuit of a SoC may be a core or avirtualization container (such as a trusted world) within a core of agiven hardware platform, and may execute a binary program. The binaryprogram may have an association with an execution context of a softwareproject. If a processor has multiple cores, some of these might work ina synchronized manner, and may be considered as forming a singlehardware execution unit.

An execution domain may be viewed as a container aggregating a hardwareexecution unit and the platform resources (e.g., internal and externalmemories, peripherals, etc.) that may be used exclusively to implement asoftware project. A shared domain may be viewed as a container forshared hardware platform resources, available several execution domains.

An execution domain can hold one or more execution contexts, that arethe containers for software project deliveries such as binary programsor interpreted code.

Such execution contexts on the same execution domain can happensequentially or complementary.

An application project may be viewed as a container aggregating allexecution contexts and their associated software projects required torun an application on a given hardware platform.

Accordingly, execution contexts are associated with hardware executionunits. For example, each boot sequence execution context is linked to anexecution domain holding the resources for the synchronization of thehardware execution circuits involved in the execution of the bootsequence. Each execution context also hosts a software projectcontaining the software components to implement the boot sequence, whichmay be synchronized in various manners.

In a boot sequence each hardware execution unit (e.g., core or trustzone world or virtualization container) may have a defined role. A coremay be a first core to boot, and may be designated as a master, and maybe in charge of starting the other core(s), which may be designated asslaves. For example, with reference to FIG. 1 , core 114 x may be thefirst to boot, and may control or start the boot process for cores 114 ato 114 n. A master core may start other or slave cores sequentially(using calls to start the slave cores) or in parallel with a gating. Aslave may have a synchronization point with a master. In someembodiments, a plurality of cores may start at the same time and waitfor each other to be ready, without cores of the plurality beingconfigured as master or slave cores.

A SoC may have a set of configuration pins (see configuration pins 118of FIG. 1 ), whose state is sampled or read at boot time as part ofconfiguring the SoC, as well as option bytes (see option bytes 117 ofFIG. 1 ) stored in non-volatile memory (see memory 116 of FIG. 1 ) whosevalues are sampled or read at boot time as part of the process ofconfigure the SoC. The option bytes may be stored in a secure area ofthe memory, such as a FLASH area which may become immutable (e.g.,write-once FLASH), a memory area associated with a trust zone, fuses,etc.

Thus, for example, a boot configuration may define a startup executioncontext, a boot address, whether gating is employed, and anysynchronization mechanism to be employed for each execution contextrunning on the same or another hardware execution unit. For example, asimple boot configuration may concern only one core, so it may not benecessary to employ any synchronization mechanism. A boot configurationinvolving several cores will have several execution contexts, and eachcore will need to have a boot context defined. Compatibility of theconfiguration with boot pin settings (e.g., configuration pins 118 ofFIG. 1 ) and option bytes will need to be considered as well.Conventionally, a user had to study the manuals for a programmablecomputing device very carefully in order to configure the boot sequenceand involved hardware execution units of a configurable computingdevice, such as the configurable computing device 108 of FIG. 1 .

The operation of one or more embodiments will now be described withrespect to FIGS. 9 and 10 , and for convenience will be described withrespect to the embodiments of FIGS. 1 through 8 described above. In atleast one of various embodiments, processes 900 and 1000 described inconjunction with FIGS. 9 and 10 , respectively, may be implemented by orexecuted on one or more computing devices, such as host computing device150 in FIG. 1 executing instructions, such as instructions 226 (see FIG.2 ) stored in the memory 156.

FIG. 9 shows a logical flow diagram of a process 900 for generatingcontent in accordance with some embodiments described herein. Process900 begins, after a start block, at block 902, where a project isinitiated for generating content to implement on or configure aprogrammable computing device, such as programmable computing device 108in FIG. 1 . In some embodiments, the project initiation includespresenting a graphical user interface to a user. The graphical userinterface requests or includes an input interface for the user to selecta particular programmable computing device. A global map or settingsregistry for the project is also initiated. The global map or settingsregistry may include a defined structure, which may be predefined, orinitial settings for the particular programmable computing device.

As described above with reference to FIG. 3 , in some embodiments, asingle project for software and hardware is initiated for theprogrammable computing device. As such, a single global map or settingsregistry may be generated. In other embodiments, a first project may beinitiated for software of the programmable computing device and a secondproject may be initiated for hardware of the programmable computingdevice. Separate global maps or settings registries may then begenerated for the separate projects. In the context of a boot sequenceconfiguration, which is a system level matter, the boot sequence setupis maintained at an overall project level, which may be referred to asan application project. Thus, dedicated global maps or settingsregistries for individual projects may also be modified to reflectchanges to the boot sequence configuration.

Process 900 proceeds from block 902 to block 904, where the process 900presents configuration options and information and obtains configurationinformation from a user to configure a boot sequence, such assynchronization mechanisms between a plurality of hardware executionunits, defining the execution context(s) of an individual executionunit, etc., using the user interface. This may be done, for example, byusing or calling the process 1000 of FIG. 10 , discussed in more detailbelow. The information presented by the user interface may include theavailable processing cores and boot sequence options (which may take theform of templates, parameters or templates and parameters), theavailable or current settings of configuration pins, the available orcurrent values of configuration option bytes stored in memory (which maytake the form of templates, parameters or templates and parameters),trust zone options (which may take the form of templates, parameters ortemplates and parameters), etc. The user may use the user interface toselect among the presented options or enter setting information directly(e.g., option bytes).

The boot sequence defines which execution contexts are triggered byother execution contexts, so these are the objects presented to the userfor selection. The available synchronization mechanisms may beconstrained by the underlying hardware execution units or domains belowthe execution contexts. For example, a simple single core MCU havingonly one hardware execution unit, may have two defined executioncontexts: a bootloader and a product application. The boot sequence maybe defined as the bootloader being started first, and the productapplication being launched by the bootloader, thus sequential temporalsharing of the same hardware execution unit is employed.

Process 900 proceeds from block 904 to block 906, where the process 900presents configuration options and information and obtains configurationinformation from a user to configure an execution domain using the userinterface. This may be done, for example, using a similar process to theprocess 300 of FIG. 3 (e.g., blocks 304 to 324, discussed on more detailabove). The information presented by the user interface may include theavailable configuration options for a selected processing core or otherhardware execution unit, the available or current settings of pertinentconfiguration pins, which may be constrained to be consistent with theboot sequence configured at block 904, the available or current valuesof pertinent configuration option bytes stored in memory, applicanttrust zone information (e.g., components in the trust world), etc. Theinformation and selections may employ templates, parameters, or variouscombinations thereof. The user may use the user interface to selectamong the presented options or enter setting information directly (e.g.,option bytes).

Process 900 proceeds from block 906 to block 908, where the process 900presents configuration options and information and obtains configurationinformation from a user to configure configurable components of asoftware project associated with the execution domain. This may be done,for example, using the processes 300 and 400 of FIGS. 3 and 4 ,discussed in more detail above. For example, blocks 304 through 324 ofprocess 300 may be performed to configure configurable hardware andsoftware components associated with the hardware execution domain.

Process 900 proceeds from block 908 to decision block 910, where adetermination is made whether the user is to select another executiondomain to be associated with a project for configuration. If anotherexecution domain is selected, process 900 loops from block 910 to block906 to configure the next execution domain; otherwise, process 900 flowsfrom block 910 to block 912.

At block 912, content generated for the involved software projects isbuilt into binary images, e.g., one binary image per software project.At block 912, the content generated for the involved software projectsis built into binary images, e.g., one binary image per softwareproject. The binary images are the information usable by theprogrammable computing device to initialize, configure, or control itshardware, software, or a combination thereof. In some embodiments, allgenerated content is utilized to build the binary image for a softwareproject. In other embodiments, a portion, but not all of the generatedcontent is utilized to build the binary image for the software project.For example, in the case of interpreted languages, only specific content(e.g., generated code) may be uploaded in a specific memory region ofthe programmable computing device without regenerating the binaryinterpreting it.

It is noted that the content is not limited to content built into binaryimages. Other examples of content that may be generated include filescontaining a configuration of objects to be applied (e.g., a set ofvalues or a set of commands interpreted by a programming tool), adocument or display explaining other configuration details to a user(e.g., how to configure the boot pins, how to alter solder bridges,etc.), general purpose documents such as a boot sequence chart, etc.,and various combinations thereof.

As illustrated, process 900 proceeds from block 912 to block 914, wherethe binary images are provided to the programmable computing device. Insome embodiments, process 900 may be executed multiple times to generatedifferent content for different configurations of the programmablecomputing device, or different types of content (e.g., binary code,explanatory documents, etc.). In this way, in addition to generatingdifferent types of content, different configurations can be provided toseparate programmable computing devices (even if a same type ofprogrammable computing device), or different configuration can beprovided to a single programmable computing device to allow a user ofthe programmable computing device to change between the differentconfigurations. After block 914, process 900 terminates or otherwisereturns to a calling process to perform other actions.

Embodiments of the process 900 illustrated in FIG. 9 may have moreprocess blocks than illustrated, may have fewer process blocks thanillustrated, and the process flow may be modified in various ways. Forexample, process 900 may be modified to configure multiple hardwareexecution units in parallel instead of sequentially, to add a decisionblock to configure additional elements before triggering code generationat 912, to generate a report or document explaining the boot sequenceinstead of or in addition to generating code at 912, to include errorprocessing, such as notifying a user of incompatible or inconsistentuser selections, to combine block 904 and 906, to omit block 914, etc.

FIG. 10 shows a logical flow diagram of a process 1000 for generatingcontent associated with configuring a boot sequence of a SoC inaccordance with some embodiments described herein. For example, process1000 may be employed to configure the boot sequence of the programmablecomputing device 108 of FIG. 1 . Process 1000 may be called by anotherprocess, such as by process 900 at block 904.

After a start block, process 1000 proceeds to block 1002, where theprocess 1000 presents current configuration pin settings and optionallya list of configuration pin options using a user interface. The process1000 may read or retrieve the configuration pin settings of aprogrammable computing device, and display those settings using the userinterface. The display also may include other information which isdependent on the configuration pin settings, or the ramifications of thecurrent configuration pin settings. For example, the configuration pinsettings may define the available boot sequence options or thecompatible option byte values, and this information may be displayedalong with the current configuration pin settings. Information regardingpotential changes to the configuration pin settings also may bepresented. For example, a configuration pin setting may control whethera particular processing core can serve as a master to another processingcore, and the user interface may display an indication of the settingswhich enable or disable such functionality, and how to change the pinsetting. In another example, information may be presented regarding anyconstraints on the configuration pin settings, such as information thata particular pin is not connected on a selected board. An example userinterface 1100 is shown in FIG. 11 and discussed in more detail below.

The process 1000 proceeds from block 1002 to determination block 1004,where the process 1000 determines whether the configuration pin settingshave changed. For example, the user interface may allow the user to,after manually changing the pin settings, select or provide anindication that the configuration pin settings have been reset. In someembodiments, the process 1000 may read or retrieve the configurationpins settings periodically or in response to a user selection (e.g.,selection of an option byte value or a boot sequence option, to, forexample, confirm that the configuration pin settings are compatible withthe user selection or have not changed. When it is determined that theconfiguration pin settings have changed or been reset, the process 1000loops from block 1004 to block 1002 to update the presentedconfiguration pin settings, options and related information. When it isnot determined at 1004 that the configuration pin settings have beenchanged or reset, the process proceeds from block 1004 to block 1006.

At block 1006, the process 1000 presents current option byte values orsettings, and optionally a list of option byte options or a field inwhich an option byte value may be entered using a user interface (e.g.,templates, parameters or templates and parameters may be presented tothe user for selection). The process 1000 may read or retrieve theoption byte values (e.g., default values) of a programmable computingdevice, and display those values using the user interface. The displayalso may include other information which is dependent on the optionbytes values, to display the ramifications of the current option bytevalues and possible changes thereto. For example, the option byte valuesmay define the available boot sequence options or the compatibleconfiguration pin settings, and this information may be displayed alongwith the current option byte values. Information regarding changes tothe option byte values also may be presented. For example, an optionbyte value may define resources available to a processing core, or atrust zone associated with a processing core, and the user interface maydisplay an indication of the how the option byte values impact suchfunctionality. An example user interface 1100 is shown in FIG. 11 anddiscussed in more detail below.

The process 1000 proceeds from block 1006 to block 1008, where theprocess 1000 receives the user-selected option byte values. For example,a user may select an option byte value from a list of values for theoption byte, select a set of option byte values for a set of optionbytes, enter an option byte value, and various combinations thereof.

The process proceeds from block 1008 to decision block 1010, where theprocess 1000 determines whether the option byte templates or parametervalues have changed. For example, the user interface may detectselection or entry of a different option byte value. In someembodiments, the process 1000 may read, retrieve or modify the optionbyte settings in response to another user selection (e.g., selection ofa boot sequence option incompatible with the current option byteselections, modification of a configuration pin setting inconsistentwith the selected option byte values, etc.). When it is determined thatthe option byte selections or values have changed, the process 1000loops from block 1010 to block 1006 to update the presented option bytevalues, options and related information. When it is not determined at1010 that the option byte values have been changed, the process proceedsfrom block 1010 to block 1012.

At block 1012, the process 1000 presents a list of boot sequenceoptions. The presented list of boot sequence options may be defined bythe current configuration pin settings and selected option byte values,or may include options which, when selected, modify or instruct the userto modify the selected option byte values, instruct the user to modifythe current configuration pin settings, or various combinations thereof.The display also may include other information which is dependent on theboot sequence option selected, to display the ramifications of thevarious boot sequence options. For example, a particular boot sequenceoption may define resources available in an execution context, limittrust zones, etc.

Information regarding changes to the selected boot sequence options alsomay be presented. For example, a selected boot sequence option maydefine resources available to a processing core, or a trust zoneassociated with a processing core, and the user interface may display anindication of the how the boot sequence options impact suchfunctionality.

Presenting a boot sequence option may include presenting sub-options andconfiguration selections. For example, a boot sequence option to set aparticular processing core as a master may include sub-options orselections to select whether the master processing core starts the slaveprocessing cores sequentially or in parallel, to display and select fromavailable synchronization protocols and resources. In some embodiments,selecting a synchronization protocol may automatically selectsynchronization resources to be employed. For example, drivers to handlehardware semaphores or an asymmetric multiprocessing application tohandle core-to-core communications may be automatically selected. Inanother example, options to introduce software component in theexecution contexts of hardware execution units may be presented.

As noted above, an example user interface 1100 is shown in FIG. 11 anddiscussed in more detail below.

The process 1000 proceeds from block 1012 to block 1014, where theprocess 1000 receives the user-selected boot sequence option and anysub-options or selections. In at least one embodiment, a user may selecta boot sequence option and any sub-options or selections from presentedlists via the graphical user interface.

The process 1000 proceeds from bock 1014 to block 1016, where theprocess 1000 updates the settings structures, the global map or settingsregistry, or both. This may include any global map or settings registryof any impacted project as well as a system level global map or settingsregistry of the boot sequence configuration. Updating the settingsstructures and the global maps or settings registry may be done, forexample, as discussed above with reference to blocks 318 and 320 of theprocess 300 of FIG. 3 . After block 1016, process 1000 returns to acalling process (e.g., process 900) to perform other actions orterminates.

Embodiments of the process 1000 illustrated in FIG. 10 may have moreprocess blocks than illustrated, may have fewer process blocks thanillustrated, and the process flow may be modified in various ways. Forexample, process 1000 may be modified to perform blocks 1002 to 1004associated with the configuration pin settings, blocks 1006 to 1010associated with the option byte options and values, and blocks 1012 to1014 associated with the boot sequence options in various orders or inparallel, instead of in the illustrated sequence, may be modified topresent option byte settings while restricting or prohibiting changes tothe option byte values, may be modified to include error processingblocks, such as blocks to notify a user of incompatible or inconsistentuser selections, etc.

FIG. 11 is an illustrative example of a graphical user interface 1100 toenable a user to select templates and parameters for a boot sequence ofa programmable computing device in accordance with embodiments describedherein. This graphical user interface 1100 can display differentconfigurations and possible values for multiple templates, parameters,and boot sequence options depending on the configuration of aprogrammable computing device, such as the configuration pin settings,and the option byte states. As illustrated, based on the currentconfiguration pin settings, three boot sequence options are presented,CM7 as a master core and CM4 as a slave core, CM4 as a master core andCM7 as a slave core, and CM7 and CM4 booting in parallel. Someembodiments may present more, or fewer, boot sequence options. Asillustrated the user has selected CM7 and CM4 booting in parallel.

In a selected boot sequence option, the user may select asynchronization protocol, which may include no synchronization,optionally selecting synchronization code from a template, or indicatingcustom synchronization code will be provided, for example, when ahardware execution unit is configured or a configurable component isconfigured. Drop down menus or pop-up menus may be employed to allow theuser to make selections or enter configuration information. For example,when a pop-up menu may appear when a user indicates code is to beselected from a set of templates. The user also may select or enter aboot address and an execution context associated with the core. Forexample, each core may be assigned to a different software project orexecution context. The user interface as illustrated also includes anSRAM Load selector, which may allow the user to assign to the master RAM(e.g., internal or external SRAM) to load slave code from flash forexecution by the slave, a data configuration selector for the master toset data sections and a stack pointer for a slave, etc.

A process (e.g., process 1000 of FIG. 10 ) employing a user interface,such as the user interface 1100 of FIG. 11 , may include checks asselections are made by the user. For example, if a user selection isinconsistent with a current configuration pin setting or an option bytesvalue, the user may be prompted to manually modify the configuration pinsettings or modify the option bytes, or the option bytes selections maybe changed based on the selection. In another example, only compatibleboot configuration selections may be presented, or alternatively, aftera boot configuration selection is made, only compatible option bytevalues may be presented for selection.

FIG. 11 is for illustrative purposes and should not be considered aslimiting. Other information or data may displayed to a user via thegraphical user interfaces in accordance with embodiments describedherein. In addition, the process 1000 and the user interface 1100 may beemployed to configure a programmable computing device having more thantwo cores, more than one system on a chip (e.g., a board having multipleSoCs), etc. Such a computing device may be configured with multiplemasters having respective slaves, etc.

Programmable computing devices, such as a programmable SoC, are becomingmore complex and often utilize different software-configurableperipherals or components. A SoC may, for example, have many multipleinternal peripherals (e.g., a timer, a UART, I2C, SPI, etc.) andmultiple external peripherals (e.g., dedicated or general-purposeinput/output interfaces), such as described above with reference to FIG.1 . The configuration of these peripherals or components may becontrolled at the software level, at the hardware level, or variouscombinations thereof. The configuration of one such peripheral, however,often relies on the configuration of other peripherals, which the usermay or may not know about and may already be used for anotherperipheral. This complexity makes such configurations time consuming,error prone, and can lead to duplicate or incorrect use of someperipherals.

A computer architecture and a method for utilizing a graphical userinterface, such as those described above with respect to FIGS. 1-11 ,may be arranged to enable a user to select specific parameters of one ormore SoC peripherals and to generate settings code and other content toconfigure the SoC in accordance with the user-selected peripherals andparameters. The code and content may also include instructions to assistthe user in making any physical changes to the SoC consistent with thedesired configuration (e.g., jumper setting instructions, such asconfiguring a UART to 115200 bauds with RX pin on GPIO AO and TX pin onGPIO A1, pad to bond information, etc).

FIGS. 12A and 12B (collectively, FIG. 12 ) illustrate an example of agraphical user interface 1200 to enable a user to select and configureperipherals of a programmable computing device in accordance withembodiments described herein. For convenience, FIGS. 12A and 12B will bedescribed with reference to FIGS. 1-8 . The graphical user interface1200 can display different peripherals and GPIOs in conceptual layersand facilitates user configuration of the peripherals and theconnections between nodes of the peripherals of the layers. In FIG. 12 ,the graphical user interface 1200 represents or presents thecapabilities of a set of internal peripherals as a tree 1202 includingan instance layer 1210, a GPIO layer 1230, and a package pin layer 1250,and the possible couplings and connections between the layers. For easeof illustration, three layers are shown in the user interface 1200 ofFIG. 12 . The graphical user interface 1200 may have more than threelayers, or fewer than three layers, depending, for example, on thecomplexity of the programmable computing device, or a configurationproject associated with the graphical user interface 1200.

The instance layer 1210 includes a plurality of peripherals 1212, asillustrated a timer or clock TIM1, an analog to digital converter ADC, aGPIO interface GPIOA, an I2C interface I2C3, and a second GPIO interfaceGPIOB. For example, the internal peripherals 132 and the GPIO 134 of theprocessing core 114 a of FIG. 1 may be represented as peripherals 1212of an instance layer 1210 of the user interface 1200 of FIG. 12 .Similarly, the internal peripherals 132 and the GPIO 134 of theprocessor 110 a may be represented as peripherals 1212 of an instancelayer 1210 of the user interface 1200 of FIG. 12 . In another example,pertinent internal peripherals 132 and GPIOs 134 of multiple SoCs 109may be presented in one or more instance layers. Internal peripherals132 which are not pertinent to a particular configuration project (e.g.,not available for use in the project context) may be omitted from thepresentation of the user interface 1200. The GPIO layer 1230 includes aplurality of nodes 1232, as illustrated nodes PA0, PB1, and PA2, of aGPIO. For example, the GPIO 134 of the processor 110 a of FIG. 1 may berepresented as GPIO layer 1230 of the user interface 1200 of FIG. 12 .Similarly, the GPIO 134 of the programmable computing device 108 of FIG.1 may be represented as a GPIO layer 1230 of the user interface 1200 ofFIG. 12 . In another example, multiple GPIOs 134 of multiple SoCs 109may be presented in one or more GPIO layers.

The user interface 1200 illustrates possible signal couplings 1220between the peripherals 1212 of an instance layer 1210 and nodes 1232 ofa GPIO layer 1230. The signal couplings between an instance layer 1210and a GPIO layer 1230 may be controlled by software (e.g., controllingswitches, controlling multiplexers, controlling signal timing, etc., andvarious combinations thereof), settings in memory (e.g., settings files224, option bytes 117), configuration pins, etc. For ease ofillustration, the signal couplings 1212 are illustrated in FIG. 12 asunidirectional signal couplings to transmit a signal from a peripheraldevice 1212 of the set of peripheral devices to a node 1232 of theplurality of nodes. Embodiments may include bidirectional signalcouplings and unidirection signal couplings to transmit a signal from anode 1232 of the plurality of nodes to a peripheral device 1212 of theset of peripheral devices, and various combinations thereof.

The representation of possible signal couplings 1220 may be updated, inreal time or otherwise, as selections are made by the user, as selectionchecks are performed by the system 150 (e.g., software coherency checks,electrical behavior checks, etc.). This may be done, for example, basedon the global map or settings registry 222, the settings files 224 orother temporary selection indicators (e.g., prior to completing of aconfiguration project and updating of the global map or settingsregistry 222), stored information regarding characteristics of theprogrammable computing device and components thereof, etc., and variouscombinations thereof.

In FIG. 12A, the signal couplings 1220 are illustrated as dashed linesto indicate all the present signal couplings are available forselection. FIG. 12A, for example, may illustrate a user interface 1200at the beginning of an internal peripheral configuration process.

In FIG. 12B, example signal couplings 1220 which have been selected areillustrated as solid lines, signal couplings 1220 which remain availableare illustrated as dashed lines having dashes of a uniform length, andsignal couplings 1220 which are not available (e.g., as a result ofanother signal coupling or configuration selection) are illustrated asdash lines of varying lengths. FIG. 12B, for example, may illustrate auser interface 1200 at a beginning stage, an intermediate or a finalstage of an internal peripheral configuration process.

In the example of FIG. 12B, a signal coupling 1220 between peripheral1212 ADC and pad 1232 PA0 is illustrated as selected, the signalcouplings 1220 between other peripherals 1212 of the instance layer 1210and pad 1232 PA0 are illustrated as not available, the signal couplings1220 between other peripherals 1212 of the instance layer 1210 and pad1232 PB1 are illustrated as available, and the signal coupling 1220between peripheral 1212 GPIOA and pad 1232 PA2 is shown as selected.

Other methods of illustrating whether a signal coupling 1220 isselected, available, or unavailable may be employed (e.g., differentcolors), and additional or fewer indications of coupling availabilitymay be indicated (e.g., timing restrictions may be indicated,unavailable signal couplings may be omitted, etc.), and the indicationsmay change as different peripherals are selected for configuration(e.g., when the timer TIM1 is selected for configuration, signalcouplings 1220 associated with the timer TIM1 may be displayed, whileother signal couplings are not displayed by the user interface 1200 orare displayed in shadow).

In FIG. 12 , GPIOA is represented in the internal peripherals 1212twice, to facilitate indicating additional signal coupling capabilitiesof the GPIOA (e.g., to couple to PA0 or PA2). For example, PA0 may becoupled to GPIOA as an input, while at the same time, PA2 is coupled toGPIOA as an output. Presenting GPIOA twice makes the presentationclearer.

The pin layer 1250 of the graphical user interface 1200 as illustratedincludes a plurality of pins 1252, as illustrated pins 1 and 4, whichfacilitate coupling a programmable computing device to external devices,such as external peripherals (e.g., interfaces, controllers, etc., notshown). For example, pins of the input/output interface 112 of theprogrammable computing device 108 of FIG. 1 which are pertinent to aconfiguration project may be represented as pins 1252 of the pin layer1250 of the user interface 1200 of FIG. 12 . Similarly, pins of aninput-output interface 112 of a SoC 109 may be represented as pins 1252of the pin layer 1250 of the user interface 1200 of FIG. 12 . In anotherexample, pertinent pins 1252 of the programmable computing device 108,and of one or more SoCs 109 may be presented in one or more pin layers.

The user interface 1200 illustrates possible connections or bonds 1240between the pads 1232 of the GPIO layer 1230 and the pins 1252 of thepin layer 1250. The connections or bonds 1240 between the GPIO layer1230 and the pin layer 1250 may typically be controlled by configurationpins or may be physical bonds, etc. In some cases, a connections or bond1240 may be controlled by software, or various combinations ofconfiguration pins, physical bonds, and software.

For ease of illustration, the connections or bonds 1240 are illustratedin FIG. 12 as unidirectional signal couplings to transmit a signal froma GPIO node 1232 of the plurality of nodes to a pad 1252 of theplurality of pins of the pin layer 1250. Embodiments may includebidirectional connections or bonds and unidirectional connections orbonds, and various combinations thereof.

The representation of possible connections or bonds 1240 may be updated,in real time or otherwise, as selections are made by the user, asselection checks are performed by the system 150 (e.g., softwarecoherency checks, electrical behavior checks, etc.) This may be done,for example, based on the global map or settings registry 222, settingsfiles 224 or other temporary selection indicators (e.g., prior tocompleting of a configuration project and updating of the global map orsettings registry), stored information regarding characteristics of theprogrammable computing device and components thereof, etc., and variouscombinations thereof.

In FIG. 12A, all of the connections or bonds 1240 are illustrated asdashed lines to indicate the connection or bond 1240 is available forselection. In FIG. 12B, example connections or bonds 1240 which havebeen selected are illustrated as solid lines, example connections orbonds 1240 which remain available are illustrated as dashed lines havingdashes of a uniform length, and connections or bonds 1240 which are notavailable (e.g., as a result of another coupling, connection orconfiguration selection) are illustrated as dash lines of varyinglengths. As shown in FIG. 12B, a connection or bond 1240 between pad1232 PA0 and pin 1252 1 is illustrated as selected, a connection or bond1240 between pad 1232 PB1 and pin 1252 1 is illustrated as available, aconnection or bond between pad 1232 PB1 and pin 1252 4 is illustrated asnot available, and a connection between pad 1232 and pin 1252 4 isillustrated as connected. In the illustrated configuration of FIG. 12B,internal peripheral 1212 ADC is coupled to pin 1252 1 through pad 1232PA0 (e.g., to facilitate measurement by the ADC of a signal received inpin 1 of an SoC), and at the same time internal peripheral 1212 GPIOA iscoupled to pin 1252 4 through pad 1232 PA2 (e.g., to facilitate GPIOAoperating in input or output mode with respect to signals on pad PA2corresponding to pin 4).

Other methods of illustrating whether a connection 1240 is selected,available, or unavailable may be employed (e.g., different colors), andadditional or fewer indications of coupling availability may beindicated (e.g., timing restrictions may be indicated, unavailablesignal couplings may be omitted, etc.), and the indications may changeas different peripherals are selected for configuration (e.g., when thetimer TIM1 is selected for configuration, connections or bonds 1240associated with configuration of the timer TIM1 may be displayed, whileother connections or bonds 1240 are not displayed by the user interface1200), as different configuration projects are performed, etc.

FIG. 12B illustrates examples of selected signal couplings 1220 andconnections or bonds 1240, and not limiting. Other signal couplings (notshown) may be employed. For example, in an embodiment a signal coupling1220 between internal peripheral 1212 timer TIM1 and pad 1232 PA0 may beselected, and a signal coupling 1220 between internal peripheral 1212ADC may be selected, for example, to provide a clock signal generated bytimer TIM1 to the ADC (not shown), and the connection or bond 1240between pad 1232 PA0 may be selected to make the clock signal availableto an external device.

The operation of one or more embodiments will now be described withrespect to FIG. 13 , and for convenience will be described with respectto the embodiments of FIGS. 1 through 8 and 12 described above. In atleast one of various embodiments, process 1300 described with referenceto FIG. 13 may be implemented by or executed on one or more computingdevices, such as host computing device 150 in FIG. 1 executinginstructions, such as instructions 226 (see FIG. 2 ) stored in thememory 156.

FIG. 13 shows a logical flow diagram of a process 1300 for generatingcontent in accordance with some embodiments described herein. Process1300 begins, after a start block, at block 1302, where a project isinitiated for generating content to implement on or configure aprogrammable computing device, such as programmable computing device108, SoC 109 in FIG. 1 , etc. In some embodiments, the projectinitiation includes presenting a graphical user interface to a user. Thegraphical user interface requests or includes an input interface for theuser to select a particular programmable computing device. A global mapor settings registry for the project may be initiated or retrieved. Theglobal map or settings registry may include a defined structure, whichmay be predefined, or initial settings for the particular programmablecomputing device.

As described above with reference to FIG. 3 , in some embodiments, asingle project for software and hardware is initiated for theprogrammable computing device. As such, a single global map or settingsregistry may be generated. In other embodiments, a first project may beinitiated for software of the programmable computing device and a secondproject may be initiated for hardware of the programmable computingdevice. Separate global maps or settings registries may then begenerated for the separate projects.

Process 1300 proceeds from block 1302 to block 1304, where the process1300 presents configuration options and information and obtainsconfiguration information from a user to configure one or more internalperipherals, such as configuration settings of the internal peripheral(see FIGS. 7 and 8 ) signal couplings between one or more internalperipheral of an instance layer and pads of a GPIO layer (see FIGS. 12Aand 12B), connections between one or more pads of a GPIO layer and oneor more pins of a pin layer (see FIGS. 12A and 12B), etc., and variouscombinations thereof. This may be done, for example, by using or callingthe process 300 of FIG. 3 (e.g., blocks 304 to 320, discussed above).The information presented by the user interface may take the form oftemplates, parameters or templates and parameters, for example asdescribed above with respect to FIGS. 1-8 , as well as presentation ofsignal couplings and connections, for example, as described above withreference to FIGS. 12A and 12B. Multiple user interfaces may beemployed. The user may use the user interface to select among thepresented options or enter setting information directly.

For example, with reference to FIG. 12 , a user may select one of theinternal peripherals 1212 (e.g., clock or timer TIM1) for configurationby selecting the representation of the timer TIM1 in the user interface1200. An option to set the timer parameters may be presented, andprocess 300 of FIG. 3 may be called to set the timer parameter. The usermay select a signal coupling between the timer TIM1 and an available pad(as illustrated in FIG. 12A, pad 1232 PA0 is available for selection inassociation with TIM1), and a connection between a pad and a pin (asillustrated in FIG. 12 , a connection between pad PA0 and pin 1 isavailable for selection). In some embodiments, the user may select a pinto be associated with a signal of a peripheral, and the process 1300 mayselect appropriate coupling and connections to configure the peripheralsignal to be associated with the selected pin.

Process 1300 proceeds from block 1304 to block 1306, where the process1300 preforms software coherency checks, electrical behavior checks,etc. This may be done, for example, based on the global map or settingsregistry 222, settings files 224 or other temporary selectionindicators, stored information regarding characteristics of theprogrammable computing device and components thereof (e.g., the internalperipherals), etc., and various combinations thereof. Examples ofcoherency and electrical behavior checks are discussed below in thedescription of FIGS. 14 and 15 .

Process 1300 proceeds from block 1306 to block 1308, where adetermination is made as to whether the software coherency andelectrical checks have been passed. When it is determined at block 1308that the coherency and electrical checks have been passed, the process1300 proceeds from block 1308 to block 1310.

At block 1310, a determination is made whether the user is to selectanother internal peripheral for configuration. If another internalperipheral is to be selected, process 1300 loops from block 1310 toblock 1304 to select and configure the next internal peripheral;otherwise, process 1300 flows from block 1310 to block 1312.

At block 1312, the content generated for the internal peripheral isbuilt, for example, into binary images. The binary images are theinformation usable by the programmable computing device to initialize,configure, or control its hardware, software, or a combination thereof.In some embodiments, all generated content is utilized to build thebinary image for a project. In other embodiments, a portion, but not allof the generated content is utilized to build the binary image for theproject. For example, in the case of a connection or bond between a padand a pin, instructions to facilitate making the connection or bond maybe generated.

Process 1300 proceeds from block 1312 to block 1314, where the binaryimages are provided to the programmable computing device. In someembodiments, process 1300 may be executed multiple times to generatedifferent content for different configurations of the programmablecomputing device. In this way, different configurations can be providedto separate programmable computing devices (even if a same type ofprogrammable computing device), or different configuration can beprovided to a single programmable computing device to allow a user ofthe programmable computing device to change between the differentconfigurations. After block 1314, process 1300 terminates or otherwisereturns to a calling process to perform other actions.

When it is not determined at block 1308 that the coherency andelectrical checks have been passed, the process 1300 proceeds from block1308 to block 1316, where configuration error processing is performed,such as providing the user with information regarding the failure or acoherency or electrical check (e.g., identify a nature of a conflictgiven rise to the failure, other components or internal peripheralsrelated to the conflict, etc.), presenting options for addressing thefailure (e.g., returning to block 1304 to reconfigure the internalperipheral, reconfiguring another component or internal peripheral,etc.).

Embodiments of the process 1300 illustrated in FIG. 13 may have moreprocess blocks than illustrated, may have fewer process blocks thanillustrated, and the process flow may be modified in various ways. Forexample, process 1300 may be modified to configure multiple internalperipherals in parallel instead of sequentially, to add a decision blockto configure additional elements before triggering code generation at1312, to generate a report or document explaining the internalperipheral configurations (e.g., pin settings, a schematic of the signalconnections, etc.), instead of or in addition to generating code at1312, to include additional error processing, such as notifying a userof incompatible or inconsistent user selections, to combine block 1304and 1306, to omit block 1314, etc.

FIG. 14 is a conceptual diagram illustrating signal coupling coherencychecks according to an embodiment. On the left, with reference to theorientation of FIG. 14 , a signal coupling between an analog signalinput of ADC1 and pad PA0 is selected. In addition, a signal couplingbetween an analog signal input of ADC2 and pad PA0 is selected. Thepertinent configurations of pad PA0 and of ADC1 and ADC2 are checked.The pertinent configuration information (e.g., in the settings registry222) indicates oversampling is permitted, and the coherency check ispassed.

On the right, again with reference to the orientation of FIG. 14 , asignal coupling between internal peripheral GPIOA in output mode and padPA0 is selected, as well as a signal coupling between interface I2C1 inalternative function mode and pad PA0 is selected. The pertinentconfiguration of pad PA0, GPIOA and IcC1 are checked. The pertinentconfiguration information (e.g., in the settings registry 222) indicatesPA0 cannot be configured to operate in output mode and alternative modeat the same time, thus the coherency check is not passed. With referenceto FIG. 13 , process 1300 detects at block 1308 a coherence checkfailure and proceeds to block 1316 where error processing may occur.

FIG. 15 is a conceptual diagram illustrating electrical integrity checksaccording to an embodiment. On the left, with reference to theorientation of FIG. 15 , a signal coupling between an analog signalinput of an ADC and pad PA0 is selected. In addition, a signal couplingbetween an analog signal output of a DAC and pad PB1 is selected. PadsPA0 and PB1 both are selected to have connections or bonds to pin 1 ofthe pin layer. The pertinent configurations of the ADC, the DAC, padsPA0 and PB1, and of pin 1 are checked. The pertinent configurationinformation (e.g., in the settings registry 222) indicates no electricalrisk is presented, and the electrical integrity check is passed.

On the right, again with reference to the orientation of FIG. 15 , asignal coupling between internal peripheral GPIOA in output mode and padPA0 is selected, as well as a signal coupling between GPIOB in outputmode and pad PB1. Pads PA0 and PB1 both are selected to have connectionsor bonds to pin 1 of the pin layer. The pertinent configurations of theGPIOA, GPIOB, pads PA0 and PB1, and of pin 1 are checked. The pertinentconfiguration information (e.g., in the settings registry 222) indicatesan electrical risk is presented, and the electrical integrity check isnot passed. With reference to FIG. 13 , process 1300 detects at block1308 an electrical integrity check failure and proceeds to block 1316where error processing may occur.

FIGS. 16 to 18 are illustrative examples of a component parameters filesin accordance with embodiments described herein. In FIG. 16 , thecomponent parameters files identify characteristics of signalsassociated with internal peripherals of the programmable computingdevice, such as internal peripherals presented in an instance layer of auser interface, such as the user interface 1200 of FIG. 12 . In FIG. 17, the pertinent components, signal couplings and connections or bonds ofthe programmable computing device are identified. FIG. 18 illustrateshow the component parameters file of FIG. 17 indicates the userselection of internal peripheral GPIOA having an input associated withpin 4.

Embodiments may facilitate avoiding duplication of information, reducingthe time required to design and implement a product, reducingconfiguration errors, and reducing the complexity of the presentation ofthe information. In an embodiment, the configuration information isstored and presented as a tree, which facilities using mathematical treeprocessing techniques to maintain and present the configurationinformation.

Embodiments also may facilitate checking (e.g., software consistencychecking and electrical integrity checking) as part of the configurationprocess, and prompt incorporation of innovations and changes intechnology into the design process (e.g., multi-bonding capabilities).An embodiment may facilitate configuring internal peripheral componentsof a programmable computing device to communicate with external devicesvia pins of the programmable computing device.

Programmable computing devices, such as a programmable SoC, may have anumber of different system states which may require configuration. Suchsystem states may have various resource configurations (e.g.,operational states of various components). In addition, transitions fromone system state to another system state may need to be configured forthe programmable computing device. For example, an application may havea plurality of application states relating to various functions of theapplication, and may transition between the various application states.These application states and transitions between the application statesmay typically be defined by an application developer using appropriatetools. However, these application states may be associated with varioussystem states, and transitions between the application states may resultin a need to transition from one system state to a new system state.

FIG. 19 is a conceptual diagram illustrating application statetransitions in the context of a coffee machine control application(e.g., transitions between application states of a state machinecontrolling the coffee machine), and associated system statetransitions. The coffee machine (not shown), may have, for example, acontrol screen, a UART for debugging, a pulse-width modulator (PWM)controller to drive components of the coffee machine (e.g., grinder,water heater, etc.), and an LED to alert a user to any fault conditions(e.g., water out, filter clogged, etc.). As illustrated, there are nineapplication states for the coffee machine control application, and fivesystem states associated with the coffee machine controller system. Onesystem state may be suitable for multiple application states; the systemmay have the same configuration or state, but the application may havedifferent states with different commands and algorithms.

For example, as illustrated the application states AppState_Standby andAppState_Selftests are both associated with the system stateSysState_Standby (in which the UART is configured to be off, the screenis configured to be off, and the PWM controller is configured to be at20%). An application state transition from the application stateAppState_Standby to the application state AppState_Selftests does notrequire a transition between system states.

However, transitions between application states associated withdifferent system states may have associated transitions between systemstates. For example, transitions from the application stateAppState_Standby to the application state AppState_Coffee is associatedwith a transition from the system state SysState_Standby to the systemstate SysState_On. In the system state SysState_On, the UART is off, thescreen is on, and the PWM controller is configured to be at 100%. Thetransition between system states SysState_Standby and SysState_On needsto be defined.

In various embodiments, the user may be presented with a graphical userinterface that enables the user to select system states, system statetransitions, or a combination thereof for the programmable computingdevice. Once configured, the programmable computing device can performvarious embodiments described herein to configure transitions from onesystem state to another system state. The operation of one or moreembodiments will now be described with respect to FIGS. 20-25 , and forconvenience will be described with respect to the embodiments describedabove. In at least one of various embodiments, process 2000 described inconjunction with FIG. 20 may be implemented by or executed on one ormore computing devices, such as host computing device 150 in FIG. 1 . Inat least one of various embodiments, processes 2100 and 2200 describedin conjunction with FIGS. 21 and 22 , respectively, may be implementedby or executed on one or more computing devices, such as programmablecomputing device 108 in FIG. 1 .

FIG. 20 shows a logical flow diagram of a process 2100 for generatingcontent defining system states and transitions in accordance withembodiments described herein. Process 2000 begins, after a start block,at block 2002 where a project is initiated for generating content toimplement on or configure system states and transitions of aprogrammable computing device, such as programmable computing device 108in FIG. 1 . In some embodiments, the project initiation includespresenting a graphical user interface to a user. The graphical userinterface requests or includes an input interface for the user to selecta particular programmable computing device. A global map or settingsregistry for the project is also initiated. The global map or settingsregistry may include a defined structure or initial settings for theparticular programmable computing device, e.g., a default structure orinitial settings. In various embodiments, block 2002 may employembodiments of block 302 in FIG. 3 to initiate one or more projects.

Process 2000 proceeds to block 2004, where a list of a plurality ofpossible system states for the project are presented to the user in thegraphical user interface. In at least one embodiment, the list ofpossible system states may be generated for the user based on theparticular programmable computing device selected for the project. Thesesystem states may be those system states that are designed for orcompatible with the programmable computing device. In some embodiments,the list of system states may also be selected for presentation based onthe execution context specificities of the programmable computingdevice. In some architectures, an execution context for a particularprocessing core or a particular mode of operation (e.g. TrustZone mode)may be selected by the user. The list of system states presented to theuser can be dependent on these user selections.

The list of system states may include configurable system states (e.g.,configurable components, such as configurable components 204 in FIG. 2), or non-configurable system states (e.g., non-configurable components,such as ready-to-go components 220 in FIG. 2 ), or some combinationthereof. For example, a user may be presented with a list or otherinterface from which the user can define all the elements of a compoundsystem state object (e.g., an execution context, a system clockconfiguration, a power mode, etc., and various combinations thereof).

Process 2000 continues at block 2006, where a user selection of a systemstate is received. In at least one embodiment, a user may select asystem state from the list via the graphical user interface. Althoughprocess 2000 discusses a user's selection of a single system state at atime, embodiments are not so limited. In some embodiments, a pluralityof system states may be selected by a user.

Each user-selected system state defines the configuration of theexecution elements of the programmable computing device for the currentproject, which may include states for one or more execution contexts,peripheral states, or domain states. In various embodiments, theprogrammable computing device can include or utilize one or multipleSystems-on-a-Chip (SoCs) (see SoC 109 in FIG. 1 ), where each SoC canhave one or multiple processing cores and one or more memories. Theprogrammable computing device can also contain memories that areexternal to the SoCs. Accordingly, a user-selected system state mayidentify one or more resources (e.g., internal memories, externalmemories, internal or external peripherals, etc.) of the programmablecomputing device and their configurations. For example, a system statemay identify the aggregation of a clock configuration; configurations ofSoCs or processors (including pinout settings); communications betweenSoCs or processors; power settings (e.g., core low power state, powerdomains, regulators, wake-up signals, etc.); or other computing resourceconfigurations or settings.

In some embodiments, the user-selected system state may identify fromwhich other system states the programmable computing device cantransition. In other embodiments, the user-selected system state mayidentify other system states to which the programmable computing devicecan transition.

The following is an example data structure of a user-defined systemstate of the programmable computing device:

{  Id: ss0,// identifier within the application project  Label:“myStandbyState”,  XCtxt: 0,// the execution context it belongs towithin the application project  SysClkCfg: sysclk0, // the system clockconfig to apply  ResCfgs : [res0, res1, res2, res,3...] // identifiersof the configurations to be applied  Predecessors: [ss1, ss2] //identifiers of the states the programmable computing device cantransition from  AssociatedDomStates⁴: [ss0, ss7] // in case ofmulti-context, the domain states to be applied in the other executioncontexts if this one is the initiator  Regulator: main or low powerregulator,  EntryCondition: WFI or WFE }

In various embodiments, the graphical user interface may also enable theuser to define a state. In at least one embodiment, the graphical userinterface can be used by the user to type in code to execute theuser-defined state or to upload a file with such code, such as a JSONfile.

Process 2000 proceeds next to decision block 2008, where a determinationis made whether another system state is selected by the user. If anothersystem state is selected, process 2000 loops to block 2006 to receivethe user selection of the other system state; otherwise, process 2000flows to block 2010. As mentioned above, process 2000 may also beperformed with the user selecting multiple system states, which can thenbe configured by the user together or individually. In variousembodiments, the user-selected system states may also be selected andconfigured in response to or in conjunction with the selection andconfiguration of various other components, as discussed above.

At block 2010, transitions between the user-selected system states aregenerated. In some embodiments, the transitions may be determined orgenerated for the possible system states presented to the user, and insome embodiments the transitions may be pre-determined or pre-generated.In these cases, transitions associated with the user-selected systemstates are selected. In other embodiments, the transitions are definedby the user. In various embodiments, the transitions identify one ormore constraints, one or more resource settings, etc. The following isan example data structure of transitions from one user-defined systemstate (e.g., Domain State 0) of the programmable computing device toanother system state (e.g., Domain State 1):

Transition from Domain State 0 to Domain State 1:  // ***CONSTRAINT forputting the core in STOP mode : Suspend systick timer***  HAL_SuspendTick( ); // e.g., apply_transition_constraint(core.mode,STOPx  // ***PERIPHERAL atomic configuration***   //Deallocate USART3 toenable D2 enter Standby mode    HAL_RCC_USART3_CLK_DISABLE( ); // e.g.,DRIVER_Set( USART3.clock, disable  // ***SYSTEM MODE configuration***  // Configure D3 domain to follow the CPU sub-system mode.   HAL_PWREx_ConfigD3Domain(PWR_D3_DOMAIN_STOP); // e.g.,apply_transition_constraint(pwdomain.d3,cpu_slave   // Enter D3 Domainto STOP mode    HAL_PWREx_EnterSTOPMode(PWR_MAINREGULATOR_ON ,PWR_STOPENTRY_WFI,PWR_D3_DOMAIN); // e.g., DRIVER_Set( pwdomain.d3,STOP  // Enter D1 and D2 to DStandby mode   HAL_PWREx_EnterSTANDBYMode(PWR_D2_DOMAIN); // e.g.,DRIVER_Set(pwdomain.d2,SBY)   HAL_PWREx_EnterSTANDBYMode(PWR_D1_DOMAIN); // e.g.,DRIVER_Set(pwdomain.d1,SBY)

Examples of a programmable computing device executing state transitionsfrom one user-selected state to another user-selected state arediscussed in more detail below in conjunction with FIGS. 22 and 23 .

Process 2000 proceeds next at block 2012, where content for theprogrammable computing device is generated based on the user-selectedsystem states and the generated transitions. In various embodiments, thecontent includes code, settings, parameters, option bits or bytes,EEPROM data, documentation, etc., and various combinations thereof, toset, configure, or define system states or system state transitions ofthe programmable computing device. The content may comprise plain code(e.g., C code) that is used by the programmable computing device toinitialize, configure, or control a software or hardware aspect of theprogrammable computing device to set the user-selected states whenenabled and the transitions from one state to another when requested.Accordingly, the generated content may be initialization code,application code, configuration code, etc. The content may also be othersettings, parameters, or other information that initializes, configures,documents, or controls a software or hardware aspect of the programmablecomputing device. In various embodiments, the global map or settingsregistry, as described above, may be utilized to generate the content.

In some embodiments, the content is built into a binary image for theproject. This binary image is the information usable by the programmablecomputing device to initialize, configure, or control its hardware,software, or a combination thereof to support the system states andtransitions as employed by the programmable computing device. In someembodiments, all generated content is utilized to build the binary imagefor the project. In other embodiments, a portion, but not all of thegenerated content is utilized to build the binary image for the project.For example, in the case of interpreted languages, only specific content(e.g., generated code) may be uploaded in a specific memory region ofthe programmable computing device without regenerating the binaryinterpreting it.

Process 2000 continues to block 2014, where the content is provided tothe programmable computing device. In some embodiments, process 2000 maybe executed multiple times to generate different content for differentconfigurations of the programmable computing device. In this way,different configurations can be provided to separate programmablecomputing devices (even if a same type of programmable computingdevice), or different configuration can be provided to a singleprogrammable computing device to allow a user of the programmablecomputing device to change between the different configurations.

In various embodiments, the content is used by the programmablecomputing device to generate or define all possible system states ordomain states. In some embodiments, the system states are applied at theproject level and the domain states are applied at the execution contextlevel. In some embodiments, the content defines one or more executiondomains for the programmable computing device. Each execution domainidentifies each execution element and their corresponding configurationsfor each user-selected system state in that execution domain. A systemor global domain may also be defined by the content to identify eachexecution element and their corresponding configurations for each systemstate.

After block 2014, process 2000 terminates or otherwise returns to acalling process to perform other actions. Embodiments of the process2000 illustrated in FIG. 20 may have more process blocks thanillustrated, may have fewer process blocks than illustrated, and theprocess flow may be modified in various ways. For example, process 2000may be modified to include a block presenting configuration updateinformation to the user based on the updated global map or settingsregistry at 2000 (e.g., calling the process 400), or to include aconsistency check block for settings in a defined state. In anotherexample, a single global system state may be defined (bypassing thedefining of transitions). It is noted that defining a single globalsystem state may limit the ability to use inconsistent configurations.

FIG. 21 shows a logical flow diagram of a process 2100 by a programmablecomputing device for transitioning from a first system state to a secondsystem state in accordance with embodiments described herein.

Process 2100 begins, after a start block, at block 2102, where a requestis received to proceed from a first system state to a second systemstate. In various embodiments, the request may be input by a user of theprogrammable computing device. In other embodiments, an application orchange in operating characteristic may be cause the request to begenerated. For example, if the battery power of the programmablecomputing device falls below a threshold amount, then the system stateof the programmable computing device may enter a low-power state. Asanother example, the user may select to change from a secure state to anon-secure state.

Process 2100 proceeds to block 2104, where an execution element isselected for the second state. Each execution element may be a resourceof the programmable computing device and its correspondingconfiguration. An example of an execution element of the second statemay be execution element 2428 a in FIG. 24 . In some embodiments, thesecond state may identify the order in which each execution element isselected. In various embodiments, the execution element is selected fromthe execution domain associated with the domain associated with therequest to transition a domain state in that domain. In otherembodiments, the execution element is selected from a global domain totransition a system state.

Process 2100 continues at block 2106, where the selected executionelement is reset to an initial state. In some embodiments, the initialstate may be a null state from which the execution element can be putinto any valid configuration. In some embodiments, the first state fromwhich the programmable computing device is transitioning to the secondstate may be an initialization state. In such an embodiment, block 2106may not be performed because each execution element is already in aninitial state.

Process 2100 proceeds next to block 2108, where the configuration of theselected execution element for the second state is applied. As mentionedherein, an execution domain may store the configuration of the executionelement for each state. Accordingly, when the execution element isselected for the second state for that execution domain, theconfirmation information for that execution element for that state isalso obtained, which is then applied at block 2108. The programmablecomputing device may apply the selected execution element configurationby setting one or more parameters of the execution element.

Process 2100 continues next at decision block 2110, where adetermination is made whether another execution element is to beselected. In various embodiments, each execution element associated withthe second state is to be selected. If another execution element is tobe selected, process 2100 loops to block 2104; otherwise, process 2100flows to block 2112.

At block 2112, the second state is employed. In at least one embodiment,the programmable computing device may execute in accordance with thesecond state.

After block 2112, process 2100 terminates or otherwise returns to acalling process to perform other actions. Although process 2100discusses transitioning from a first state to a second state, theprogrammable computing device may have a plurality of different states.Accordingly, process 2100 can also be employed to transition from afirst state to a fourth state, from the fourth state to the secondstate, etc. depending on the states and transitions selected by the userand employed by the programmable computing device.

FIG. 22 shows a logical flow diagram of another process 2200 fortransitioning from a first state to a second state in accordance withembodiments described herein. Process 2200 begins, after a start block,at block 2202, where a request is received to proceed from a first stateto a second state. In various embodiments, block 2202 may employembodiments of block 2102 in FIG. 21 to receive the change-of-staterequest.

Process 2200 proceeds to block 2204, where an execution element isselected for the second state. In various embodiments, block 2204 mayemploy embodiments of block 2104 in FIG. 21 to select the executionelement of the second state.

Process 2200 continues at block 2206, where a configuration differencebetween the first state and the second state is determined for theselected execution element. In some embodiments, the execution domainfor the second state may identify the configuration differences betweenthe states from which the second state can transition. In otherembodiments, the programmable computing device compares the currentconfiguration of the execution element with the second stateconfiguration to determine the differences. In various embodiments, aplurality of configuration differences may be identified for theselected execution element.

Process 2200 proceeds next to block 2208, where one or more of theconfiguration differences determined at block 2206 is selected for theselected execution element. In some embodiments, the selected executionelement may identify an order in which the configuration differences areto be selected. In at least one embodiment, this order may be based onthe first state, the second state, or a combination thereof. In variousembodiments, multiple configuration differences may be selected, such asif the configuration differences are to be applied at the same time.

Process 2200 continues next at block 2210, where one or more transitionconstraints are applied for the selected configuration difference. In atleast one embodiment, the constraint is a configuration or parameterthat enables the configuration difference to be applied withoutaffecting the performance or implementation of another execution elementor component of the programmable computing device. In variousembodiments, the constraints prevent a forbidden transition or preventthe programmable computing device from entering into a non-state orinvalid condition. For example, a processor may be put into a “Stop”mode for a particular configuration difference to be applied. In variousembodiments, some configuration differences may not have a transitionconstraint.

Process 2200 proceeds to block 2212, where the configuration of theselected configuration difference is applied for the selected executionelement. In some embodiments, only the configuration difference isapplied. In other embodiments, the configuration as defined by theselected execution element is applied. In various embodiments, block2212 may employ embodiments of block 2108 in FIG. 21 to apply theconfiguration difference.

Process 2200 continues at decision block 2214, where a determination ismade whether another configuration difference is selected. In someembodiments, multiple configuration differences are sequentiallyselected, such that the transition constraints and configurationsettings can be applied for each configuration difference of theselected execution element. If another configuration difference is to beselected, process 2200 loops to block 2208; otherwise, process 2200flows to decision block 2216.

At decision block 2216, a determination is made whether anotherexecution element is to be selected. In various embodiments, eachexecution element associated with the second state is to be selected. Ifanother execution element is to be selected, process 2200 loops to block2204; otherwise, process 2200 flows to block 2218.

At block 2218, the second state is employed. In at least one embodiment,the programmable computing device may execute in accordance with thesecond state.

After block 2218, process 2200 terminates or otherwise returns to acalling process to perform other actions. Although process 2200discusses transitioning from a first state to a second state, theprogrammable computing device may have a plurality of different states.Accordingly, process 2200 can also be employed to transition from afirst state to a fourth state, from the fourth state to the secondstate, etc. depending on the states and transitions selected by the userand employed by the programmable computing device.

Embodiments of the process 2100 illustrated in FIG. 21 and of process2200 illustrated in FIG. 22 may have more process blocks thanillustrated, may have fewer process blocks than illustrated, and theprocess flow may be modified in various ways. For example, process 2100may be modified to include a block to check whether any conditions toemploying the second state are satisfied after block 2110. Similarly,process 2200 may be modified to include a block to check whether anyconditions to employing the second state are satisfied after block 2216.In another example, process 2100 shown in FIG. 21 and process 2200 shownin FIG. 22 may be modified to address synchronization issues, such assynchronization issues between different processing cores of a systemduring state transitions. For example, at some time during a process oftransitioning a first processing core (see processing core 114 a of FIG.1 ) between a first state A and a second state B, it may be necessary totransition a second processing core (see processing core 114 x of FIG. 1) from a first state C to a second state D. Thus, process 2100 orprocess 2200 may be modified, for example, to, during the process oftransitioning the first processing core from state A to state B, toinitiate a transition of the second processing core from state C tostate D, before completing the transition of the first processing corefrom state A to state B.

FIG. 23 is an illustrative example of a graphical user interface 2300 toenable a user to select states for a project in accordance withembodiments described herein. Graphical user interface 2300 may displaymultiple different possible states to the user. In this example, thegraphical user interface 2300 displays states 2302 a-2302 e to the user.State 2302 a would put the programmable computing device into a lowpower mode; state 2302 b would put a thermostat sensor of theprogrammable computing device into a low power mode; state 2302 c wouldput turn off the thermostat sensor of the programmable computing device;state 2302 d would put the programmable computing device into a securemode; and state 2302 e would put the programmable computing device intonon-secure mode.

In various embodiments, the states may be configured in a tree structureto identify different possible execution levels within the programmablecomputing device. For example, states 2302 a-2302 e may be system stateswith settings not restricted to an execution domain, and states 2310a-2310 b may be domain states with settings restricted to one executiondomain. Although not illustrated, the graphical user interface 2300 mayalso include an input functions to allow the user to define the state.

The graphical user interface 2300 displays a corresponding context 2304a-2304 e. The context 2304 a-2304 e identifies the component or owner inwhich the state 2302 a-2302 e corresponds. For example, state 2302 badjusts the state of a thermostat associated with the programmablecomputing device. The graphical user interface 2300 also displayscorresponding comments 2306 a-2306 e for each state 2302 a-2302 e. Thecomments 2306 a-2306 e provides information to the user to identify thestate and how it may operate.

The user can select a particular state by clicking on the state. In someembodiments, the graphical user interface 2300 can present (notillustrated) the user with additional options for selecting, defining,or configuring a state. The graphical user interface 2300 may alsopresent (not illustrated) transition options for the selected state.These transitions may identify the execution elements associated with atransition, whether the transition is to be performed by going to aninitialization state first, whether the transition is to determine theconfiguration differences, which states the programmable computingdevice can transition from when transitioning to the selected state,which states the programmable computing device can transition to whenstarting at the selected state, etc. In some embodiments, theuser-selected states and transitions may also be displayed to the user.

FIG. 24 is a block diagram showing an example conceptual structure 2400for managing state information utilized in generating content inaccordance with embodiments described herein. In some embodiments, theconceptual structure 2400 may be displayed to a user in a graphical userinterface to enable the user to see the execution elements associatedwith the different user-selected states, as well as their configurationinformation.

In this example, conceptual structure 2400 includes an execution context2402 and an execution domain 2420. The execution context 2402 is aproject, application, or specific use of the programmable computingdevice. The user has selected a first state 2404 and a second state 2406to be accessible and utilized by the programmable computing device.

The execution domain 2420 stores information for each execution element2422 associated with states 2404 and 2406. In this example, executiondomain 2420 includes execution element 2422 a for “Peripheral A,”execution element 2422 b for “Peripheral B,” execution element 2422 cfor a system clock, and execution element 2422 d identifying systemmodes (e.g., low power mode, secure mode, etc.). Execution element 2422a includes configuration information 2426 a for the first state 2404 andconfiguration information 2428 a for the second state 2406; executionelement 2422 b includes configuration information 2426 b for the firststate 2404 and configuration information 2428 b for the second state2406; execution element 2422 c includes configuration information 2426 cfor the first state 2404 and configuration information 2428 c for thesecond state 2406; and execution element 2422 d includes configurationinformation 2426 d for the first state 2404 and configurationinformation 2428 d for the second state 2406. In various embodiments,the configuration information includes constraints, settings,parameters, or other information utilized to configure that executionelement for that state.

If the programmable computing device is transitioning from aninitialization state to the first state 2404, then configurationinformation 2426 a-2426 d is obtained and applied, as described herein.In some embodiments, if the programmable computing device istransitioning from the first state 2404 to the second state 2406, thenconfiguration information 2428 a-2428 d is obtained and applied afterthe execution elements 2422 a-2422 d are first reset, as describedherein. In other embodiments, a configuration difference is determinedbetween the configuration information 2426 a-2426 d of the first state2404 and the configuration information 2428 a-2428 d of the second state2406 and then applied when transitioning between the first state 2404and the second state 2406, as described herein.

Although conceptual structure 2400 shows a single execution context, asingle execution domain, four execution elements, and two states,embodiments are not limited. Rather, one or more execution contexts maybe employed, one or more execution domains may be employed for one ormore of the execution context, one or more execution elements may beutilized for one or more of the execution domains, and one or morestates may be selected by the user.

FIG. 25 is an illustrative example of a transition structure 2500between user-selected states in accordance with embodiments describedherein. In this illustrative example, the user has selected a “Low PowerSleep Mode” 2502, a “Sleep Mode” 2504, a “Low Power Run Mode” 2506, a“Shutdown Mode” 2508, a “Stop 1 Mode” 2510, a “Run Mode” 2512, a“Standby Mode” 2514, a “Stop 0 Mode” 2516, and a “Stop 2 Mode” 2518. Byemploying embodiments described herein, transitions between theuser-selected states are generated for proper transitions betweenstates. In some embodiments, transition structure 2500 may be displayedto the user to enable the user to “drag and drop” the transition arrowsbetween states.

In various embodiments, a consistency checker may be employed to ensureproper transitions. For example, in some embodiments, the consistencycheck may make sure the domain state is consistent and that allperipheral configurations do not conflict (e.g., prevent turning on aperipheral using another peripheral that is turned off). In otherembodiments, the consistency checker may make sure the system state isconsistent such that domain state configurations do not conflict (e.g.,prevent a core being set in STANDBY by one domain but set to RUN mode byanother domain).

In an embodiment, a method includes: presenting, via a graphical userinterface to a user, a list of components for a project associated witha programmable computing device; receiving, via the graphical userinterface, a first selection of at least one user-selected component forthe project from the list of components; in response to the at least oneuser-selected component being configurable: presenting, via thegraphical user interface, a first list of user-selectable templates forthe at least one user-selected component; receiving, via the graphicaluser interface, a second selection of at least one user-selectedtemplate from the first list of user-selectable templates; presenting,via the graphical user interface, a second list of user-selectableparameters for the at least one user-selected component; receiving, viathe graphical user interface, a third selection of at least oneuser-selected parameter from the second list of user-selectableparameters; generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter; and generating or updating a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generating content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry. In an embodiment, the method comprises providing the contentto the programmable computing device. In an embodiment, generating thecontent comprises generating initialization code that initializessoftware of the programmable computing device based on the at least oneuser-selected component and the settings registry. In an embodiment,generating the content comprises generating initialization code thatinitializes hardware of the programmable computing device based on theat least one user-selected component and the settings registry. In anembodiment, generating the content comprises generating application codethat controls software of the programmable computing device based on theat least one user-selected component and the settings registry. In anembodiment, receiving the third selection of the at least oneuser-selected parameter comprises receiving, via the graphical userinterface, one or more values selected by the user and defined by the atleast one user-selected parameter. In an embodiment, the methodcomprises, in response to receiving the third selection of the at leastone user-selected parameter, detecting a change to a first value in thesettings registry based on the third selection and propagating thechange through the settings registry based on at least one dependencybetween the first value and at least one second value. In an embodiment,the method comprises, in response to receiving the third selection ofthe at least one user-selected parameter, detecting a change to a firstvalue in the settings registry based on the third selection and prior topropagating the change through the settings registry, updating thegraphical user interface to show changes to at least one second value inthe settings registry that is dependent on the first value. In anembodiment, the method comprises selecting the second list ofuser-selectable parameters based on the second selection of the at leastone user-selected template. In an embodiment, the method comprises, inresponse to the at least one user-selected component beingnon-configurable, generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter and updating the settings registry based onadditional settings for at least one user-selected non-configurablecomponent. In an embodiment, generating the content comprises generatingapplication content that controls software of the programmable computingdevice based on the at least one user-selected component and thesettings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:displaying, via a graphical user interface to a user, a list ofcomponents for a project associated with a programmable computingdevice; receiving, via the graphical user interface, a first selectionof at least one user-selected component for the project from the list ofcomponents; in response to the at least one user-selected componentbeing configurable: displaying, via the graphical user interface, afirst list of user-selectable templates for the at least oneuser-selected component; receiving, via the graphical user interface, asecond selection of at least one user-selected template from the firstlist of user-selectable templates; displaying, via the graphical userinterface, a second list of user-selectable parameters for the at leastone user-selected component; receiving, via the graphical userinterface, a third selection of at least one user-selected parameterfrom the second list of user-selectable parameters; generating settingsfor the at least one user-selected component based on the secondselection of the at least one user-selected template and the thirdselection of the at least one user-selected parameter; and generating orupdating a settings registry based on the settings for each of the atleast one user-selected component; and generating content for theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry. In an embodiment, the methodcomprises providing the generated content to the programmable computingdevice. In an embodiment, the method comprises, in response to receivingthe third selection of the at least one user-selected parameter,detecting a change to a first value in the settings registry based onthe third selection and propagating the change through the settingsregistry based on at least one dependency between the first value and atleast one second value. In an embodiment, the method comprises, inresponse to receiving the third selection of the at least oneuser-selected parameter: detecting a change to a first value in thesettings registry based on the third selection; updating the graphicaluser interface to show changes to at least one second value in thesettings registry that is dependent on the first value; and selectivelypropagating the change through the settings registry based on auser-response to the updated graphical user interface. In an embodiment,generating the content includes generating initialization code thatinitializes software of the programmable computing device based on theat least one user-selected component and the settings registry. In anembodiment, generating the content includes generating initializationcode that initializes hardware of the programmable computing devicebased on the at least one user-selected component and the settingsregistry. In an embodiment, the contents of the computer-readable mediumcomprise instructions executable by the processing device.

In an embodiment, a computing device comprises: a display device; amemory, which, in operation, stores computer instructions; and at leastone processor, which, in operation, executes the computer instructionsto: present, via the display device and to a user, a list of componentsfor a project associated with a programmable computing device; receive afirst selection of at least one user-selected component for the projectfrom the list of components; in response to the at least oneuser-selected component being configurable: present, via the displaydevice, a first list of user-selectable templates for the at least oneuser-selected component; receive a second selection of at least oneuser-selected template from the first list of user-selectable templates;present, via the display device, a second list of user-selectableparameters for the at least one user-selected component; receive a thirdselection of at least one user-selected parameter from the second listof user-selectable parameters; generate settings for the at least oneuser-selected component based on the second selection of the at leastone user-selected template and the third selection of the at least oneuser-selected parameter; and generate or update a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generate content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry. In an embodiment, the at least one processor, in operation,executes the computer instructions to, in response to receiving thethird selection of the at least one user-selected parameter, detect achange to a first value in the settings registry based on the thirdselection and propagate the change through the settings registry basedon at least one dependency between the first value and at least onesecond value. In an embodiment, the at least one processor, inoperation, executes the computer instructions to, in response toreceiving the third selection of the at least one user-selectedparameter, detect a change to a first value in the settings registrybased on the third selection, update a graphical user interfacedisplayed to the user to show changes to at least one second value inthe settings registry that is dependent on the first value, andselectively propagating the change through the settings registry basedon a user-response to the updated graphical user interface displayed tothe user. In an embodiment, the at least one processor, in operation,executes the computer instructions to provide the content to theprogrammable computing device. In an embodiment, the at least oneprocessor, in operation, generates the content by executing the computerinstructions to generate initialization code that initializes softwareof the programmable computing device based on the at least oneuser-selected component and the settings registry. In an embodiment, theat least one processor, in operation, generates the content by executingthe computer instructions to generate initialization code thatinitializes hardware of the programmable computing device based on theat least one user-selected component and the settings registry. In anembodiment, the at least one processor, in operation, generates thecontent by executing the computer instructions to: generateinitialization content that initializes software of the programmablecomputing device based on the at least one user-selected component andthe settings registry. In an embodiment, the at least one processor, inoperation, generates the content by executing the computer instructionsto generate initialization content that initializes hardware of theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: display, via a graphical user interface to a user, a listof components for a project associated with the programmable computingdevice; receive, via the graphical user interface, a first selection ofat least one user-selected component for the project from the list ofcomponents; in response to the at least one user-selected componentbeing configurable: display, via the graphical user interface, a firstlist of user-selectable templates for the at least one user-selectedcomponent; receive, via the graphical user interface, a second selectionof at least one user-selected template from the first list ofuser-selectable templates; display, via the graphical user interface, asecond list of user-selectable parameters for the at least oneuser-selected component; receive, via the graphical user interface, athird selection of at least one user-selected parameter from the secondlist of user-selectable parameters; generate settings for the at leastone user-selected component based on the second selection of the atleast one user-selected template and the third selection of the at leastone user-selected parameter; and generate or update a settings registrybased on the settings for each of the at least one user-selectedcomponent; generate content for the programmable computing device basedon the at least one user-selected component and the settings registry;and provide the content to the programmable computing device. In anembodiment, the programmable computing device comprises amicroprocessor, which, in operation, executes the content to initializesoftware of the programmable computing device. In an embodiment, theprogrammable computing device comprises a microprocessor, which, inoperation, executes the content to initialize hardware of theprogrammable computing device. In an embodiment, the programmablecomputing device comprises a microprocessor, which, in operation,executes the content as a software application of the programmablecomputing device.

In an embodiment, a method comprises: presenting, via a graphical userinterface to a user, a set of boot configuration options for a projectassociated with a programmable computing device, the presenting the setof boot configuration options including; presenting configuration pinsettings associated with the programmable computing device; presentingoption byte values associated with the programmable computing device;and presenting the set of boot configuration options; receiving, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generating or updating a settings registry based on theselected boot configuration option; and generating content for theprogrammable computing device based on the selected boot configurationoption and the settings registry. In an embodiment, the presenting theconfiguration pin settings comprises reading configuration pin settingsof the programmable computing device. In an embodiment, the presentingthe option byte values comprises retrieving option byte valuesassociated with the programmable computing device. In an embodiment, thepresented set of configuration options is a function of theconfiguration pin settings. In an embodiment, the presented set ofconfiguration options is a function of the option byte values. In anembodiment, the presented option byte values are a function of theselected configuration option and the method comprises selecting optionbyte settings based on the selected configuration option. In anembodiment, the presenting the set of boot configuration optionsincludes presenting a set of boot sequence options. In an embodiment,the presenting the boot sequence options includes presenting: an optionto designate a first processing core of a plurality of processing coresas a master and a second processing core of the plurality of processingcores as a slave; an option to indicate the plurality of processingcores are to be booted sequentially; an option to indicate the pluralityof processing cores are to be booted in parallel; an option to setsynchronization protocols for a processing core of the plurality ofprocessing cores; an option to set synchronization resources for aprocessing core of the plurality of processing cores; an option to set aboot address for a processing core of the plurality of processing cores;an option to set an execution context associated with a processing coreof the plurality of processing cores; an option to assign memory to amaster to store code for execution by a slave; an option to configure amaster to set a data configuration for a slave; an option to configure amaster to set a stack pointer for a slave; or combinations thereof. Inan embodiment, the method comprises providing the content to theprogrammable computing device. In an embodiment, generating the contentcomprises generating initialization code that initializes software ofthe programmable computing device based on the selected bootconfiguration option and the settings registry. In an embodiment, themethod comprises presenting, via the graphical user interface to theuser, a list of components for the project associated with theprogrammable computing device; receiving, via the graphical userinterface, a first selection of at least one user-selected component forthe project from the list of components; in response to the at least oneuser-selected component being configurable: presenting, via thegraphical user interface, a first list of user-selectable templates forthe at least one user-selected component; receiving, via the graphicaluser interface, a second selection of at least one user-selectedtemplate from the first list of user-selectable templates; presenting,via the graphical user interface, a second list of user-selectableparameters for the at least one user-selected component; receiving, viathe graphical user interface, a third selection of at least oneuser-selected parameter from the second list of user-selectableparameters; and generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter, wherein the generating or updating the settingsregistry is based on the settings for each of the at least oneuser-selected component and the generating content for the programmablecomputing device is based on the at least one user-selected componentand the settings registry.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:presenting, via a graphical user interface to a user, a set of bootconfiguration options for a project associated with a programmablecomputing device, the presenting the set of boot configuration optionsincluding; presenting configuration pin settings associated with theprogrammable computing device; presenting option byte values associatedwith the programmable computing device; and presenting the set of bootconfiguration options; receiving, via the graphical user interface, aselection of a boot configuration option for the project selected fromthe presented set of boot configuration options; generating or updatinga settings registry based on the selected boot configuration option; andgenerating content for the programmable computing device based on theselected boot configuration option and the settings registry. In anembodiment, the presenting the configuration pin settings comprisesreading configuration pin settings of the programmable computing device.In an embodiment, the presented set of configuration options is afunction of the configuration pin settings. In an embodiment, thepresenting the set of boot configuration options includes presenting aset of boot sequence options. In an embodiment, the presenting the bootsequence options includes presenting: an option to designate a firstprocessing core of a plurality of processing cores as a master and asecond processing core of the plurality of processing cores as a slave;an option to indicate the plurality of processing cores are to be bootedsequentially; an option to indicate the plurality of processing coresare to be booted in parallel; an option to set synchronization protocolsfor a processing core of the plurality of processing cores; an option toset synchronization resources for a processing core of the plurality ofprocessing cores; an option to set a boot address for a processing coreof the plurality of processing cores; an option to set an executioncontext associated with a processing core of the plurality of processingcores; an option to assign memory to a master to store code forexecution by a slave; an option to configure a master to set a dataconfiguration for a slave; an option to configure a master to set astack pointer for a slave; or combinations thereof. In an embodiment,the method comprises providing the generated content to the programmablecomputing device. In an embodiment, the method comprises: presenting,via the graphical user interface to the user, a list of components forthe project associated with the programmable computing device;receiving, via the graphical user interface, a first selection of atleast one user-selected component for the project from the list ofcomponents; in response to the at least one user-selected componentbeing configurable: presenting, via the graphical user interface, afirst list of user-selectable templates for the at least oneuser-selected component; receiving, via the graphical user interface, asecond selection of at least one user-selected template from the firstlist of user-selectable templates; presenting, via the graphical userinterface, a second list of user-selectable parameters for the at leastone user-selected component; receiving, via the graphical userinterface, a third selection of at least one user-selected parameterfrom the second list of user-selectable parameters; and generatingsettings for the at least one user-selected component based on thesecond selection of the at least one user-selected template and thethird selection of the at least one user-selected parameter, wherein thegenerating or updating the settings registry is based on the settingsfor each of the at least one user-selected component and the generatingcontent for the programmable computing device is based on the at leastone user-selected component and the settings registry. In an embodiment,the contents of the computer-readable medium comprise instructionsexecutable by the processing device.

In an embodiment, a computing device comprises: a display device; amemory, which, in operation, stores computer instructions; and at leastone processor. The at least one processor, in operation, executes thecomputer instructions to: present, via a graphical user interface to auser, a set of boot configuration options for a project associated witha programmable computing device, the presenting the set of bootconfiguration options including; presenting configuration pin settingsassociated with the programmable computing device; presenting optionbyte values associated with the programmable computing device; andpresenting the set of boot configuration options; receive, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generate or update a settings registry based on the selectedboot configuration option; and generate content for the programmablecomputing device based on the selected boot configuration option and thesettings registry. In an embodiment, the presenting the configurationpin settings comprises reading configuration pin settings of theprogrammable computing device. In an embodiment, the presented set ofconfiguration options is a function of the configuration pin settings, afunction of the option byte values, or a function of both theconfiguration pin settings and the option byte values. In an embodiment,the presenting the set of boot configuration options includes presentinga set of boot sequence options. In an embodiment, the presenting theboot sequence options includes presenting: an option to designate afirst processing core of a plurality of processing cores as a master anda second processing core of the plurality of processing cores as aslave; an option to indicate the plurality of processing cores are to bebooted sequentially; an option to indicate the plurality of processingcores are to be booted in parallel; an option to set synchronizationprotocols for a processing core of the plurality of processing cores; anoption to set synchronization resources for a processing core of theplurality of processing cores; an option to set a boot address for aprocessing core of the plurality of processing cores; an option to setan execution context associated with a processing core of the pluralityof processing cores; an option to assign memory to a master to storecode for execution by a slave; an option to configure a master to set adata configuration for a slave; an option to configure a master to set astack pointer for a slave; or combinations thereof. In an embodiment,the at least one processor, in operation, executes the computerinstructions to: present, via the graphical user interface to the user,a list of components for the project associated with the programmablecomputing device; receive, via the graphical user interface, a firstselection of at least one user-selected component for the project fromthe list of components; in response to the at least one user-selectedcomponent being configurable: present, via the graphical user interface,a first list of user-selectable templates for the at least oneuser-selected component; receive, via the graphical user interface, asecond selection of at least one user-selected template from the firstlist of user-selectable templates; present, via the graphical userinterface, a second list of user-selectable parameters for the at leastone user-selected component; receive, via the graphical user interface,a third selection of at least one user-selected parameter from thesecond list of user-selectable parameters; and generate settings for theat least one user-selected component based on the second selection ofthe at least one user-selected template and the third selection of theat least one user-selected parameter, wherein the generating thesettings registry is based on the settings for each of the at least oneuser-selected component and the generating content for the programmablecomputing device is based on the at least one user-selected componentand the settings registry.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: present, via a graphical user interface to a user, a setof boot configuration options for a project associated with theprogrammable computing device, the presenting the set of bootconfiguration options including; presenting configuration pin settingsassociated with the programmable computing device; presenting optionbyte values associated with the programmable computing device; andpresenting the set of boot configuration options; receive, via thegraphical user interface, a selection of a boot configuration option forthe project selected from the presented set of boot configurationoptions; generate or update a settings registry based on the selectedboot configuration option; and generate content for the programmablecomputing device based on the selected boot configuration option and thesettings registry. In an embodiment, the programmable computing devicecomprises a microprocessor which, in operation, executes the content toinitialize software of the programmable computing device. In anembodiment, the programmable computing device comprises a microprocessorwhich, in operation, executes the content to initialize hardware of theprogrammable computing device.

In an embodiment, a method comprises: presenting, via a graphical userinterface to a user, a set of configuration options for a projectassociated with a programmable computing device, the presenting the setof configuration options including; presenting a set of internalperipherals of the programmable computing device; presenting a set ofpads of an interface of the programmable computing device; andpresenting a set of pins of the programmable computing device;receiving, via the graphical user interface, configuration selectioninformation associating an internal peripheral of the set of internalperipherals with a pin of the set of pins; maintaining a settingsregistry based on the received configuration selection information; andgenerating content for the programmable computing device based on thereceived configuration selection information and the settings registry.In an embodiment, the presenting comprises retrieving configurationinformation from the settings registry. In an embodiment, maintainingthe settings registry comprises retrieving and updating the settingsregistry. In an embodiment, the maintaining the settings registrycomprises generating the settings registry. In an embodiment, theconfiguration selection information: identifies a signal couplingbetween the internal peripheral of the set of internal peripherals and apad of the set of pads; and identifies a connection between the pad ofthe set of pads and the pin of the set of pins. In an embodiment, theconfiguration selection information associates the internal peripheralof the set of internal peripherals with a plurality of pads of the setof pads. In an embodiment, the configuration selection informationassociates a plurality of pads of the set of pads with the pin of theset of pins. In an embodiment, the method comprises: performing asoftware coherency check in response to the received configurationselection information. In an embodiment, the method comprises:performing an electrical integrity check in response to the receivedconfiguration selection information. In an embodiment, the methodcomprises: performing a software coherency check in response to thereceived configuration selection information; and performing anelectrical integrity check in response to the received configurationselection information. In an embodiment, the performing the softwarecoherency check and the electrical integrity check comprises retrievingconfiguration information from the settings registry. In an embodiment,the presenting comprises presenting a tree structure having an instancelayer presenting the set of internal peripherals, an interface layerpresenting the set of pads, and a pin layer presenting the set of pins.In an embodiment, the presenting comprises: presenting a set of signalcouplings between internal peripherals of the set of internalperipherals and pads of the set of pads; and presenting a set ofconnections between pads of the set of pads and pins of the set of pins.In an embodiment, the method comprises: providing the content to theprogrammable computing device.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method, the methodcomprising: presenting, via a graphical user interface to a user, a setof configuration options for a project associated with a programmablecomputing device, the presenting the set of configuration optionsincluding; presenting a set of internal peripherals of the programmablecomputing device; presenting a set of pads of an interface of theprogrammable computing device; and presenting a set of pins of theprogrammable computing device; receiving, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintaining a settings registry based on the receivedconfiguration selection information; and generating content for theprogrammable computing device based on the received configurationselection information and the settings registry. In an embodiment, thecontents of the computer-readable medium comprise instructions. In anembodiment, the presenting comprises retrieving configurationinformation from the settings registry. In an embodiment, themaintaining the settings registry comprises retrieving and updating thesettings registry. In an embodiment, the maintaining the settingsregistry comprises generating the settings registry. In an embodiment,the configuration selection information identifies a signal couplingbetween the internal peripheral of the set of internal peripherals and apad of the set of pads, and identifies a connection between the pad ofthe set of pads and the pin of the set of pins. In an embodiment, theconfiguration selection information associates the internal peripheralof the set of internal peripherals with a plurality of pads of the setof pads. In an embodiment, the configuration selection informationassociates a plurality of pads of the set of pads with the pin of theset of pins. In an embodiment, the method comprises: performing asoftware coherency check in response to the received configurationselection information; performing an electrical integrity check inresponse to the received configuration selection information; orperforming a software coherency check in response to the receivedconfiguration selection information and performing an electricalintegrity check in response to the received configuration selectioninformation. In an embodiment, the method comprises providing thegenerated content to the programmable computing device.

In an embodiment, a computing device comprises a display device, amemory, which, in operation, stores computer instructions, and at leastone processor. The at least one processor, in operation, executes thecomputer instructions to: present, via a graphical user interface to auser, a set of configuration options for a project associated with aprogrammable computing device, the presenting the set of configurationoptions including; presenting a set of internal peripherals of theprogrammable computing device; presenting a set of pads of an interfaceof the programmable computing device; and presenting a set of pins ofthe programmable computing device; receive, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintain a settings registry based on the received configurationselection information; and generate content for the programmablecomputing device based on the received configuration selectioninformation and the settings registry. In an embodiment, the presentingcomprises retrieving configuration information from the settingsregistry. In an embodiment, the maintaining the settings registrycomprises retrieving and updating the settings registry. In anembodiment, the maintaining the settings registry comprises generatingthe settings registry. In an embodiment, the configuration selectioninformation: identifies a signal coupling between the internalperipheral of the set of internal peripherals and a pad of the set ofpads; and identifies a connection between the pad of the set of pads andthe pin of the set of pins. In an embodiment, the configurationselection information associates the internal peripheral of the set ofinternal peripherals with a plurality of pads of the set of pads. In anembodiment, the configuration selection information associates aplurality of pads of the set of pads with the pin of the set of pins. Inan embodiment, the at least one processor, in operation, executes thecomputer instructions to: perform a software coherency check in responseto the received configuration selection information; perform anelectrical integrity check in response to the received configurationselection information; or perform a software coherency check in responseto the received configuration selection information and perform anelectrical integrity check in response to the received configurationselection information. In an embodiment, the presenting comprisespresenting a tree structure having an instance layer presenting the setof internal peripherals, an interface layer presenting the set of pads,and a pin layer presenting the set of pins. In an embodiment, thepresenting comprises: presenting a set of signal couplings betweeninternal peripherals of the set of internal peripherals and pads of theset of pads; and presenting a set of connections between pads of the setof pads and pins of the set of pins. In an embodiment, the at least oneprocessor, in operation, executes the computer instructions to providethe content to the programmable computing device.

In an embodiment, a system comprises a programmable computing device anda non-transitory computer-readable medium. The non-transitorycomputer-readable medium has contents, which, in operation, cause aprocessor to: present, via a graphical user interface to a user, a setof configuration options for a project associated with a programmablecomputing device, the presenting the set of configuration optionsincluding; presenting a set of internal peripherals of the programmablecomputing device; presenting a set of pads of an interface of theprogrammable computing device; presenting a set of pins of theprogrammable computing device; receive, via the graphical userinterface, configuration selection information associating an internalperipheral of the set of internal peripherals with a pin of the set ofpins; maintain a settings registry based on the received configurationselection information; and generate content for the programmablecomputing device based on the received configuration selectioninformation and the settings registry. In an embodiment, theprogrammable computing device comprises a microprocessor which, inoperation, executes the content to initialize the programmable computingdevice. In an embodiment, a method comprises: presenting, by a hostcomputing device via a graphical user interface to a user, a list ofstates for a project associated with a programmable computing device;receiving, by the host computing device via the graphical userinterface, a first selection of a first user-selected state for theproject from the list of states; receiving, by the host computing devicevia the graphical user interface, a second selection of a seconduser-selected state for the project; generating, by the host computingdevice, a transition between the first user-selected state to the seconduser-selected state; generating or updating, by the host computingdevice, a settings registry based on the first user-selected state, thesecond user-selected state, and the generated transitions between thefirst user-selected state and the second user-selected state; andgenerating, by the host computing device, content for the programmablecomputing device based on the settings registry. In an embodiment, themethod comprises: providing the content to the programmable computingdevice. In an embodiment, receiving the first selection of the firstuser-selected state for the project from the list of states comprises:receiving, via the graphical user interface, a user input selecting adefined state of the programmable computing device. In an embodiment,receiving the first selection of the first user-selected state for theproject from the list of states comprises: receiving, via the graphicaluser interface, a user input selecting a system state of theprogrammable computing device. In an embodiment, receiving the firstselection of the first user-selected state for the project from the listof states comprises: receiving, via the graphical user interface, a userinput selecting a domain state of the programmable computing device. Inan embodiment, receiving the second selection of the seconduser-selected state for the project comprises: receiving, via thegraphical user interface, a user input defining a state of theprogrammable computing device. In an embodiment, generating thetransition from the first user-selected state to the seconduser-selected state comprises: selecting, by the host device, at leastone defined transition constraint for at least one execution elementassociated with the second user-selected state for transitioning fromthe first user-selected state to the second user-selected state. In anembodiment, generating the transition from the first user-selected stateto the second user-selected state comprises: receiving, by the hostdevice, at least one user-defined transition constraint for at least oneexecution element associated with the second user-selected state fortransitioning from the first user-selected state to the seconduser-selected state. In an embodiment, the method comprises: receiving,by the programmable computing device, a request to proceed from thefirst user-selected state to the second user-selected state; andtransitioning, by the programmable computing device, the programmablecomputing device from the first user-selected state to the seconduser-selected state based on the generated transitions. In anembodiment, transitioning the programmable computing device from thefirst user-selected state to the second user-selected comprises:selecting, by the programmable computing device, each execution elementassociated with the second user-selected state; obtaining, by theprogrammable computing device, a configuration for each executionelement; resetting, by the programmable computing device, each executionelement to an initial state; and applying, by the programmable computingdevice, the configuration for each execution element from the initialstate to the second user-selected state. In an embodiment, transitioningthe programmable computing device from the first user-selected state tothe second user-selected comprises: selecting, by the programmablecomputing device, each execution element associated with the seconduser-selected state; determining, by the programmable computing device,a configuration difference for each execution element between the firstuser-selected state and the second user-selected state; applying, by theprogrammable computing device, at least one transition constraint for atleast one configuration difference for at least one execution element;and applying, by the programmable computing device, the configurationdifferences for each execution element from the first user-selectedstate to the second user-selected state.

In an embodiment, a system comprises: a programmable computing devicehaving a first memory, which, in operation, stores first computerinstructions; and at least one first processor. The at least one firstprocessor, in operation, executes the first computer instructions to:receive content configuring a first user-selected state, a seconduser-selected state, and transitions between the first user-selectedstate and the second user-selected state; receive a request to proceedfrom the first user-selected state to the second user-selected state;and transition the programmable computing device from the firstuser-selected state to the second user-selected state based on thetransitions. The system includes a host computing device comprising: adisplay device; a second memory, which, in operation, stores secondcomputer instructions; and at least one second processor. The at leastone second processor, in operation, executes the second computerinstructions to: present, via the display device, a list of states for aproject associated with the programmable computing device; receive afirst selection of the first user-selected state for the project fromthe list of states; receive a second selection of the seconduser-selected state for the project; generate the transitions from thefirst user-selected state to the second user-selected state; generate asettings registry based on the first user-selected state, the seconduser-selected state, and the transitions between the first user-selectedstate and the second user-selected state; and generate the content forthe programmable computing device based on the settings registry. In anembodiment, the at least one second processor of the host computingdevice, in operation, receives the first selection of the firstuser-selected state for the project from the list of states by executingthe second computer instructions to: receive a user input selecting adefined state of the programmable computing device. In an embodiment,the at least one second processor of the host computing device, inoperation, receives the first selection of the first user-selected statefor the project from the list of states by executing the second computerinstructions to: receive a user input selecting a system state of theprogrammable computing device. In an embodiment, the at least one secondprocessor of the host computing device, in operation, generates thetransition from the first user-selected state to the seconduser-selected state by executing the second computer instructions to:receive at least one user-defined transition constraint for at least oneexecution element associated with the second user-selected state fortransitioning from the first user-selected state to the seconduser-selected state. In an embodiment, the at least one first processorof the programmable computing device, in operation, transitions theprogrammable computing device from the first user-selected state to thesecond user-selected by executing the first computer instructions to:select each execution element associated with the second user-selectedstate; obtain a configuration for each execution element; reset eachexecution element to an initial state; and apply the configuration foreach execution element from the initial state to the seconduser-selected state. In an embodiment, the at least one first processorof the programmable computing device, in operation, transitions theprogrammable computing device from the first user-selected state to thesecond user-selected by executing the first computer instructions to:select each execution element associated with the second user-selectedstate; determine a configuration difference for each execution elementbetween the first user-selected state and the second user-selectedstate; apply at least one transition constraint for at least oneconfiguration difference for at least one execution element; and applythe configuration differences for each execution element from the firstuser-selected state to the second user-selected state.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a processing device to perform a method. The method comprises:presenting, via a graphical user interface to a user, a list of statesfor a project associated with a programmable computing device;receiving, via the graphical user interface, a first selection of afirst user-selected state for the project from the list of states;receiving, via the graphical user interface, a second selection of asecond user-selected state for the project; generating a transition fromthe first user-selected state to the second user-selected state;maintain a settings registry based on the first user-selected state, thesecond user-selected state, and the generated transitions between thefirst user-selected state and the second user-selected state; andgenerating content for the programmable computing device based on thesettings registry. In an embodiment, the contents of thecomputer-readable medium comprise instructions executable by theprocessing device. In an embodiment, the method comprises: providing thecontent to the programmable computing device. In an embodiment,receiving the first selection of the first user-selected state for theproject from the list of states comprises: receiving, via the graphicaluser interface, a user input selecting a defined state of theprogrammable computing device; receiving, via the graphical userinterface, a user input selecting a system state of the programmablecomputing device; receiving, via the graphical user interface, a userinput selecting a domain state of the programmable computing device; orcombinations thereof. In an embodiment, receiving the second selectionof the second user-selected state for the project comprises: receiving,via the graphical user interface, a user input defining a state of theprogrammable computing device. In an embodiment, generating thetransition from the first user-selected state to the seconduser-selected state comprises: selecting at least one defined transitionconstraint for at least one execution element associated with the seconduser-selected state for transitioning from the first user-selected stateto the second user-selected state. In an embodiment, generating thetransition from the first user-selected state to the seconduser-selected state comprises: receiving at least one user-definedtransition constraint for at least one execution element associated withthe second user-selected state for transitioning from the firstuser-selected state to the second user-selected state.

In an embodiment, a non-transitory computer-readable medium's contentsconfigure a microcontroller of a programmable computing device toperform a method. The method comprises: receiving content configuring afirst user-selected state, a second user-selected state, and transitionsbetween the first user-selected state and the second user-selectedstate; receiving a request to proceed from the first user-selected stateto the second user-selected state; and transitioning the programmablecomputing device from the first user-selected state to the seconduser-selected state based on the received content by: selecting eachexecution element associated with the second user-selected state;determining a configuration difference for each execution elementbetween the first user-selected state and the second user-selectedstate; applying at least one transition constraint for at least oneconfiguration difference for at least one execution element; andapplying the configuration differences for each execution element fromthe first user-selected state to the second user-selected state. In anembodiment, transitioning the programmable computing device from thefirst user-selected state to the second user-selected comprises:selecting, by the programmable computing device, each execution elementassociated with the second user-selected state; obtaining, by theprogrammable computing device, a configuration for each executionelement; resetting, by the programmable computing device, each executionelement to an initial state; and applying, by the programmable computingdevice, the configuration for each execution element from the initialstate to the second user-selected state. In an embodiment, transitioningthe programmable computing device from the first user-selected state tothe second user-selected comprises: selecting, by the programmablecomputing device, each execution element associated with the seconduser-selected state; determining, by the programmable computing device,a configuration difference for each execution element between the firstuser-selected state and the second user-selected state; applying, by theprogrammable computing device, at least one transition constraint for atleast one configuration difference for at least one execution element;and applying, by the programmable computing device, the configurationdifferences for each execution element from the first user-selectedstate to the second user-selected state.

In an embodiment, a computing device comprises a memory, which, inoperation, stores computer instructions, and at least one processor. Theat least one processor, in operation, executes the computer instructionsto: present, via a display device, a list of states for a projectassociated with a programmable computing device; receive a firstselection of a first user-selected state for the project from the listof states; receive a second selection of a second user-selected statefor the project; generate transitions from the first user-selected stateto the second user-selected state; generate a settings registry based onthe first user-selected state, the second user-selected state, and thetransitions between the first user-selected state and the seconduser-selected state; and generate content for the programmable computingdevice based on the settings registry. In an embodiment, the at leastone processor, in operation, receives the first selection of the firstuser-selected state for the project from the list of states by executingthe second computer instructions to: receive a user input selecting adefined state of the programmable computing device. In an embodiment,the at least one processor, in operation, receives the first selectionof the first user-selected state for the project from the list of statesby executing the second computer instructions to: receive a user inputselecting a system state of the programmable computing device. In anembodiment, the at least one processor, in operation, generates thetransition from the first user-selected state to the seconduser-selected state by executing the second computer instructions to:receive at least one user-defined transition constraint for at least oneexecution element associated with the second user-selected state fortransitioning from the first user-selected state to the seconduser-selected state.

The headings and Abstract of the Disclosure provided herein are forconvenience only and do not limit or interpret the scope or meaning ofthe embodiments.

The various embodiments described above can be combined to providefurther embodiments. Aspects of the embodiments can be modified, ifnecessary to employ concepts of the various patents, application andpublications to provide yet further embodiments.

These and other changes can be made to the embodiments in light of theabove-detailed description. In general, in the following claims, theterms used should not be construed to limit the claims to the specificembodiments disclosed in the specification and the claims, but should beconstrued to include all possible embodiments along with the full scopeof equivalents to which such claims are entitled. Accordingly, theclaims are not limited by the disclosure.

1. A method, comprising: presenting, via a graphical user interface to auser, a list of components for a project associated with a programmablecomputing device; receiving, via the graphical user interface, a firstselection of at least one user-selected component for the project fromthe list of components; in response to the at least one user-selectedcomponent being configurable: presenting, via the graphical userinterface, a first list of user-selectable templates for the at leastone user-selected component; receiving, via the graphical userinterface, a second selection of at least one user-selected templatefrom the first list of user-selectable templates; presenting, via thegraphical user interface, a second list of user-selectable parametersfor the at least one user-selected component; receiving, via thegraphical user interface, a third selection of at least oneuser-selected parameter from the second list of user-selectableparameters; generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter; and generating or updating a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generating content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry.
 2. The method of claim 1, comprising: providing the content tothe programmable computing device.
 3. The method of claim 1, whereingenerating the content comprises: generating initialization code thatinitializes software of the programmable computing device based on theat least one user-selected component and the settings registry.
 4. Themethod of claim 1, wherein generating the content comprises: generatinginitialization code that initializes hardware of the programmablecomputing device based on the at least one user-selected component andthe settings registry.
 5. The method of claim 1, wherein generating thecontent comprises: generating application code that controls software ofthe programmable computing device based on the at least oneuser-selected component and the settings registry.
 6. The method ofclaim 1, wherein receiving the third selection of the at least oneuser-selected parameter comprises: receiving, via the graphical userinterface, one or more values selected by the user and defined by the atleast one user-selected parameter.
 7. The method of claim 1, comprising:in response to receiving the third selection of the at least oneuser-selected parameter: detecting a change to a first value in thesettings registry based on the third selection; and propagating thechange through the settings registry based on at least one dependencybetween the first value and at least one second value.
 8. The method ofclaim 1, comprising: in response to receiving the third selection of theat least one user-selected parameter: detecting a change to a firstvalue in the settings registry based on the third selection; and priorto propagating the change through the settings registry, updating thegraphical user interface to show changes to at least one second value inthe settings registry that is dependent on the first value.
 9. Themethod of claim 1, comprising: selecting the second list ofuser-selectable parameters based on the second selection of the at leastone user-selected template.
 10. The method of claim 1, comprising: inresponse to the at least one user-selected component beingnon-configurable: generating settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter; and updating the settings registry based onadditional settings for at least one user-selected non-configurablecomponent.
 11. The method of claim 1, wherein generating the contentcomprises: generating application content that controls software of theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.
 12. A non-transitorycomputer-readable medium having contents that configure a processingdevice to perform a method, the method comprising: displaying, via agraphical user interface to a user, a list of components for a projectassociated with a programmable computing device; receiving, via thegraphical user interface, a first selection of at least oneuser-selected component for the project from the list of components; inresponse to the at least one user-selected component being configurable:displaying, via the graphical user interface, a first list ofuser-selectable templates for the at least one user-selected component;receiving, via the graphical user interface, a second selection of atleast one user-selected template from the first list of user-selectabletemplates; displaying, via the graphical user interface, a second listof user-selectable parameters for the at least one user-selectedcomponent; receiving, via the graphical user interface, a thirdselection of at least one user-selected parameter from the second listof user-selectable parameters; generating settings for the at least oneuser-selected component based on the second selection of the at leastone user-selected template and the third selection of the at least oneuser-selected parameter; and generating or updating a settings registrybased on the settings for each of the at least one user-selectedcomponent; and generating content for the programmable computing devicebased on the at least one user-selected component and the settingsregistry.
 13. The non-transitory computer-readable medium of claim 12,wherein the method comprises: providing the generated content to theprogrammable computing device.
 14. The non-transitory computer-readablemedium of claim 12, wherein the method comprises: in response toreceiving the third selection of the at least one user-selectedparameter: detecting a change to a first value in the settings registrybased on the third selection; and propagating the change through thesettings registry based on at least one dependency between the firstvalue and at least one second value.
 15. The non-transitorycomputer-readable medium of claim 12, wherein the method comprises: inresponse to receiving the third selection of the at least oneuser-selected parameter: detecting a change to a first value in thesettings registry based on the third selection; updating the graphicaluser interface to show changes to at least one second value in thesettings registry that is dependent on the first value; and selectivelypropagating the change through the settings registry based on auser-response to the updated graphical user interface.
 16. Thenon-transitory computer-readable medium of claim 12, wherein generatingthe content includes: generating initialization code that initializessoftware of the programmable computing device based on the at least oneuser-selected component and the settings registry.
 17. Thenon-transitory computer-readable medium of claim 12, wherein generatingthe content includes: generating initialization code that initializeshardware of the programmable computing device based on the at least oneuser-selected component and the settings registry.
 18. Thenon-transitory computer-readable medium of claim 12, wherein generatingthe content includes: generating application code that controls softwareof the programmable computing device based on the at least oneuser-selected component and the settings registry.
 19. Thenon-transitory computer-readable medium of claim 12, wherein thecontents of the computer-readable medium comprise instructionsexecutable by the processing device.
 20. A computing device, comprising:a display device; a memory, which, in operation, stores computerinstructions; and at least one processor, which, in operation, executesthe computer instructions to: present, via the display device and to auser, a list of components for a project associated with a programmablecomputing device; receive a first selection of at least oneuser-selected component for the project from the list of components; inresponse to the at least one user-selected component being configurable:present, via the display device, a first list of user-selectabletemplates for the at least one user-selected component; receive a secondselection of at least one user-selected template from the first list ofuser-selectable templates; present, via the display device, a secondlist of user-selectable parameters for the at least one user-selectedcomponent; receive a third selection of at least one user-selectedparameter from the second list of user-selectable parameters; generatesettings for the at least one user-selected component based on thesecond selection of the at least one user-selected template and thethird selection of the at least one user-selected parameter; andgenerate or update a settings registry based on the settings for each ofthe at least one user-selected component; and generate content for theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.
 21. The computing device of claim20, wherein the at least one processor, which, in operation, executesthe computer instructions to: in response to receiving the thirdselection of the at least one user-selected parameter: detect a changeto a first value in the settings registry based on the third selection;and propagate the change through the settings registry based on at leastone dependency between the first value and at least one second value.22. The computing device of claim 20, wherein the at least oneprocessor, which, in operation, executes the computer instructions to:in response to receiving the third selection of the at least oneuser-selected parameter: detect a change to a first value in thesettings registry based on the third selection; update a graphical userinterface displayed to the user to show changes to at least one secondvalue in the settings registry that is dependent on the first value; andselectively propagating the change through the settings registry basedon a user-response to the updated graphical user interface displayed tothe user.
 23. The computing device of claim 20, wherein the at least oneprocessor, which, in operation, executes the computer instructions to:provide the content to the programmable computing device.
 24. Thecomputing device of claim 20, wherein the at least one processor, which,in operation, generates the content by executing the computerinstructions to: generate initialization code that initializes softwareof the programmable computing device based on the at least oneuser-selected component and the settings registry.
 25. The computingdevice of claim 20, wherein the at least one processor, which, inoperation, generates the content by executing the computer instructionsto: generate initialization code that initializes hardware of theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.
 26. The computing device of claim20, wherein the at least one processor, which, in operation, generatesthe content by executing the computer instructions to: generateapplication code that controls software of the programmable computingdevice based on the at least one user-selected component and thesettings registry.
 27. The computing device of claim 20, wherein the atleast one processor, which, in operation, generates the content byexecuting the computer instructions to: generate initialization contentthat initializes software of the programmable computing device based onthe at least one user-selected component and the settings registry. 28.The computing device of claim 20, wherein the at least one processor,which, in operation, generates the content by executing the computerinstructions to: generate initialization content that initializeshardware of the programmable computing device based on the at least oneuser-selected component and the settings registry.
 29. The computingdevice of claim 20, wherein the at least one processor, which, inoperation, generates the content by executing the computer instructionsto: generate application content that controls software of theprogrammable computing device based on the at least one user-selectedcomponent and the settings registry.
 30. A system, comprising: aprogrammable computing device; and a non-transitory computer-readablemedium having contents, which, in operation, cause a processor to:display, via a graphical user interface to a user, a list of componentsfor a project associated with the programmable computing device;receive, via the graphical user interface, a first selection of at leastone user-selected component for the project from the list of components;in response to the at least one user-selected component beingconfigurable: display, via the graphical user interface, a first list ofuser-selectable templates for the at least one user-selected component;receive, via the graphical user interface, a second selection of atleast one user-selected template from the first list of user-selectabletemplates; display, via the graphical user interface, a second list ofuser-selectable parameters for the at least one user-selected component;receive, via the graphical user interface, a third selection of at leastone user-selected parameter from the second list of user-selectableparameters; generate settings for the at least one user-selectedcomponent based on the second selection of the at least oneuser-selected template and the third selection of the at least oneuser-selected parameter; and generate or update a settings registrybased on the settings for each of the at least one user-selectedcomponent; generate content for the programmable computing device basedon the at least one user-selected component and the settings registry;and provide the content to the programmable computing device.
 31. Thesystem of claim 30, wherein the programmable computing device comprises:a microprocessor which, in operation, executes the content to initializesoftware of the programmable computing device.
 32. The system of claim30, wherein the programmable computing device comprises: amicroprocessor which, in operation, executes the content to initializehardware of the programmable computing device.
 33. The system of claim30, wherein the programmable computing device comprises: amicroprocessor which, in operation, executes the content as a softwareapplication of the programmable computing device.